solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void solution() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
cout << 1 + ((c - a) * (d - b)) << endl;
}
int main() {
int x;
cin >> x;
while (x--) solution();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[2505][2505], fa[2505], dep[2505], p[2505], bo[2505];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
if (i == j && a[i][j] != 0) {
puts("NOT MAGIC");
return 0;
}
if (i > j && a[i][j] != a[j][i]) {
puts("NOT MAGIC");
return 0;
}
}
bo[1] = 1;
for (int i = 2; i <= n; i++) fa[i] = 1, p[i] = a[1][i], dep[i] = 1;
for (int i = 2; i <= n; i++) {
int minn = 2000000000, minp;
for (int j = 1; j <= n; j++)
if (minn > p[j] && bo[j] == 0) minp = j, minn = p[j];
bo[minp] = 1;
for (int j = 1; j <= n; j++)
if (bo[j] == 0 && p[j] > a[minp][j]) {
fa[j] = minp;
dep[j] = dep[minp] + 1;
p[j] = a[minp][j];
}
}
for (int i = 1; i < n; i++)
for (int j = i + 1; j <= n; j++) {
int x = i, y = j;
if (dep[x] < dep[y]) swap(x, y);
if (a[x][y] > max(a[fa[x]][x], a[fa[x]][y])) {
puts("NOT MAGIC");
return 0;
}
}
puts("MAGIC");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long zero = 1, b = 0, answ = 1;
int n, *a;
cin >> n;
a = new int[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
b += a[i];
if (a[i] == 0) {
if (b != 0) {
zero++;
if (i == (n - 1)) break;
if (a[i + 1] == 0) continue;
}
} else
zero = 1;
answ *= zero;
}
if (b == 1)
answ = 1;
else if (b == 0)
answ = 0;
cout << answ;
delete[] a;
cin >> b;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
long long int res = 1;
a %= 1000000007;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
long long int modInverse(long long int a) { return power(a, 1000000007 - 2); }
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
long long int gdp(long long int a, long long int b) { return (a - (a % b)); }
long long int ld(long long int a, long long int b) {
if (a < 0) return -1 * gdp(abs(a), b);
if (a % b == 0) return a;
return (a + (b - a % b));
}
long long int gd(long long int a, long long int b) {
if (a < 0) return (-1 * ld(abs(a), b));
return (a - (a % b));
}
long long int ncr(long long int n, long long int k) {
long long int res = 1;
if (k > n - k) k = n - k;
for (long long int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
const int N = 500023;
bool vis[N];
vector<int> adj[N];
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPowerOfTwo(int n) {
if (n == 0) return false;
return (ceil(log2(n)) == floor(log2(n)));
}
void solve() {
int n, i, j, x, y;
cin >> n;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
int count = 1, min = n + 1;
j = 0;
while (j != n - 1) {
min = n + 1;
for (i = j; i < n; i++)
if (a[i] < min) {
min = a[i];
x = i;
}
for (i = x; i >= j + 1; i--) a[i] = a[i - 1];
a[j] = min;
if (j == x) {
j++;
continue;
}
j = x;
}
for (i = 0; i < n; i++) cout << a[i] << " ";
cout << "\n";
}
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
cin >> T;
int t = 0;
while (t++ < T) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long bit[200005], m, a[200005], num[200005];
long long sum(long long i) {
long long s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(long long i, long long first) {
while (i <= m) {
bit[i] += first;
i += i & -i;
}
}
int main() {
long long n, i, j, k;
ios::sync_with_stdio(false);
;
cin >> m;
for (i = 1; i <= m; i++) cin >> a[i];
long long ans = 0;
for (i = 1; i <= m; i++) {
ans += (i - 1 - sum(a[i]));
add(a[i], 1);
}
if (ans & 1)
ans = ans * 2 - 1;
else
ans = ans * 2;
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class F, class T>
T convert(F a, int p = -1) {
stringstream ss;
if (p >= 0) ss << fixed << setprecision(p);
ss << a;
T b;
ss >> b;
return b;
}
template <class T>
void print(T a, int p = -1) {
if (p >= 0) cout << fixed << setprecision(p);
cout << a;
}
template <class T>
bool isPrime(T a) {
if (a == 1) return false;
T n = (T)sqrt(a);
for (T i = 2; i <= n; i++)
if (a % i == 0) return false;
return true;
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int dx[] = {-1, 0, +1, 0};
const int dy[] = {0, +1, 0, -1};
const int inf = (int)1e9 + 5;
const long long linf = (long long)1e16 + 5;
const double eps = 1e-9;
const double pi = 3.141592654;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
if ((int)s.find('0') == -1)
cout << s.substr(0, ((int)(s).size()) - 1) << endl;
else {
s.erase(s.find('0'), 1);
cout << s << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int r, c;
cin >> r >> c;
string str[r];
for (int i = 0; i < r; i++) {
cin >> str[i];
}
int ar = 0;
int ac = 0;
bool ok = true;
for (int i = 0; i < r && ok; i++) {
for (int j = 0; j < c && ok; j++) {
if (str[i][j] == 'B') {
ok = false;
ar += i;
ac += j;
}
}
}
ok = true;
for (int i = r - 1; i >= 0 && ok; i--) {
for (int j = c - 1; j >= 0 && ok; j--) {
if (str[i][j] == 'B') {
ok = false;
ar += i;
ac += j;
}
}
}
ar /= 2;
ac /= 2;
ar++;
ac++;
cout << ar << " " << ac << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0;
char c;
while ((c = getchar()) < '0' || c > '9')
;
do {
s = s * 10 + c - '0';
} while ((c = getchar()) >= '0' && c <= '9');
return s;
}
const int N = 100010;
int n, m, t, rev, rt;
vector<char> mp[N];
bool work() {
int i, j;
if (t > (n - 1) * (m - 1) * 4) return 0;
for (i = 1; i <= n; i++) mp[i].resize(m + 1);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) mp[i][j] = '.';
mp[1][1] = mp[2][1] = '*';
for (i = 2; i <= n; i++) {
if (i > 2) t--, mp[i][1] = '*';
j = 2;
if (t < 4) break;
for (j = 2; j <= m && t >= 4; j++)
mp[i - 1][j - 1] = mp[i - 1][j] = mp[i][j - 1] = mp[i][j] = '*',
t -= (i > 2 && j == m) ? 3 : 4;
if (t < 4) break;
}
if (i == 2 && j <= m) {
switch (t) {
case 1:
mp[1][j] = '*';
break;
case 2:
if (j == 2)
mp[2][2] = mp[3][1] = '*';
else
mp[1][j] = mp[3][1] = '*';
break;
case 3:
if (j == 2) mp[3][3] = mp[2][3] = '*';
mp[1][j] = mp[3][j - 1] = mp[3][j] = '*';
break;
}
} else {
switch (t) {
case 1:
if (j < m)
mp[i][m] = '*';
else if (i < n)
mp[i + 1][1] = '*';
else
return 0;
break;
case 2:
if (j < m - 1)
mp[i][m - 1] = '*';
else if (i < n && j > 3)
mp[i + 1][2] = '*';
else if (i < n && j <= m)
mp[i + 1][j] = mp[i + 1][j - 1] = '*';
else
return 0;
break;
case 3:
if (j < m - 2)
mp[i][m] = mp[i][m - 2] = '*';
else if (j == m)
mp[i][j] = '*';
else if (i < n) {
if (j < m) {
mp[i][m] = mp[i + 1][m - 1] = mp[i + 1][j] = mp[i + 1][j - 1] = '*';
if (j == 2) mp[i + 1][m] = '*';
} else if (m >= 4) {
mp[i + 1][1] = mp[i + 1][m - 1] = '*';
if (j == m) mp[i + 1][m] = '*';
} else
return 0;
} else
return 0;
break;
}
}
return 1;
}
int main() {
int i, j, y;
for (int T = read(); T--;) {
n = read();
m = read();
y = t = read();
if (!work()) {
swap(n, m);
t = y;
if (!work())
puts("-1");
else {
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++) putchar(mp[j][i]);
puts("");
}
}
} else
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) putchar(mp[i][j]);
puts("");
}
if (T) puts("");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using ii = pair<int, int>;
static ll pow2cost(ll k) {
if (k == 0LL) return 0LL;
return (1LL << (k - 1)) * k;
}
int main() {
ll n;
cin >> n;
ll ans = 0;
ll last = 0;
for (ll k = 60; k >= 0; k--) {
if (n >> k) {
n -= 1LL << k;
ans += pow2cost(k);
ans += last;
last = 1LL << k;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4.1,sse4.2,popcnt,avx,avx2,tune=native")
using namespace std;
const int BUF_SIZE = 4096;
int readChar() {
static unsigned char buf[BUF_SIZE];
static int buf_pos = 0, buf_len = 0;
if (buf_pos == buf_len) {
buf_pos = 0;
buf_len = fread(buf, 1, BUF_SIZE, stdin);
if (!buf_len) return -1;
}
return buf[buf_pos++];
}
template <class T = int>
T readInt() {
T x = 0;
int c;
while ((c = readChar()) <= 32)
;
while (c > 32) x = x * 10 + c - '0', c = readChar();
return x;
}
const int MOD = 998244353;
int mul(int a, int b) { return (int64_t)a * b % MOD; }
void add(int &a, int b) {
if ((a += b) >= MOD) a -= MOD;
}
int dp[36][1 << 15];
int main() {
ios_base::sync_with_stdio(0);
int n = readInt();
int m = readInt();
int k = 0;
vector<int64_t> a(m + 1), b(m);
vector<int> p(m), u(m);
for (int i = 0; i < (n); i++) {
a[k] = readInt<int64_t>();
for (int j = 0; j < (k); j++)
if ((((a[k]) >> (p[j])) & 1)) a[k] ^= a[j];
if (a[k]) {
p[k] = 0;
while (!(((a[k]) >> (p[k])) & 1)) p[k]++;
u[p[k]] = 1;
for (int j = 0; j < (k); j++)
if ((((a[j]) >> (p[k])) & 1)) a[j] ^= a[k];
k++;
}
}
for (int i = 0; i < (k); i++) {
int pos = 0;
for (int j = 0; j < (m); j++)
if (!u[j]) b[i] |= (((a[i]) >> (j)) & 1) << pos++;
assert(pos == m - k);
}
vector<int> ans(m + 1);
int ma = min(k, 20);
fprintf(stderr, "k=%d m=%d ma=%d\n", k, m, ma), fflush(stderr);
if (k <= ma) {
fprintf(stderr, "case 1\n"), fflush(stderr);
if (m - k <= 31) {
int x = 0, cnt = 0;
ans[0]++;
for (int i = 1; i < (1 << k); i++) {
int j = 0;
while (!(((i) >> (j)) & 1)) cnt--, x ^= b[j], j++;
cnt++, x ^= b[j];
ans[cnt + __builtin_popcount(x)]++;
}
} else {
for (int i = 0; i < (1 << k); i++) {
int64_t x = 0;
for (int j = 0; j < (k); j++)
if ((((i) >> (j)) & 1)) x ^= a[j];
ans[__builtin_popcountll(x)]++;
}
}
} else {
fprintf(stderr, "case 2\n"), fflush(stderr);
int x = 0, cnt = 0;
dp[0][0]++;
for (int i = 1; i < (1 << ma); i++) {
int j = 0;
while (!(((i) >> (j)) & 1)) cnt--, x ^= b[j], j++;
cnt++, x ^= b[j];
dp[cnt][x]++;
}
for (int i = ma; i < k; i++)
for (int j = i; j >= 0; j--)
for (int mask = 0; mask < (1 << (m - k)); mask++)
add(dp[j + 1][mask ^ b[i]], dp[j][mask]);
for (int j = 0; j < (k + 1); j++)
for (int mask = 0; mask < (1 << (m - k)); mask++)
add(ans[j + __builtin_popcount(mask)], dp[j][mask]);
}
int pow = 1;
for (int i = 0; i < (n - k); i++) pow = mul(pow, 2);
for (int x : ans) cout << mul(x, pow) << " ";
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int ara[] = {2, 7, 2, 3, 3, 4, 2, 5, 1, 2};
int main() {
string s;
cin >> s;
int n = s[0] - '0';
int sum = ara[n];
n = s[1] - '0';
sum *= ara[n];
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
long long gav = 0;
int n, dig, k;
int num[15];
int arr[15];
int nem[15];
int hana[15];
long long ans;
void bctr(int x, int le) {
if (x == le) {
long long q1 = 1, q2 = 0;
if (le != dig) {
for (int i = 0; i < le; i++) {
if (nem[i] == 0) {
if (i == 0)
q1 *= 7;
else
q1 *= 8;
} else
q1 *= 2, q2++;
}
} else {
int kel[5];
q1 = 0;
kel[0] = 0, kel[1] = 0;
for (int i = 0; i < le; i++) kel[nem[i]]++;
q2 = kel[1];
for (int i = 0, j = le - 1; i < le; i++, j--) {
if (nem[i] == 0) {
int bas = 0;
if (i == 0) bas = 1;
kel[0]--;
gav = 1;
for (int jj = bas; jj < arr[j]; jj++) {
if (jj != 4 && jj != 7) {
gav = 1;
for (int tt = 0; tt < kel[0]; tt++) gav *= 8;
for (int tt = 0; tt < kel[1]; tt++) gav *= 2;
q1 += gav;
}
}
if (arr[j] == 4 || arr[j] == 7) break;
} else {
kel[1]--;
if (arr[j] < 4) break;
if (arr[j] > 4) {
gav = 1;
for (int tt = 0; tt < kel[0]; tt++) gav *= 8;
for (int tt = 0; tt < kel[1]; tt++) gav *= 2;
q1 += gav;
if (arr[j] < 7) break;
}
if (arr[j] > 7) {
gav = 1;
for (int tt = 0; tt < kel[0]; tt++) gav *= 8;
for (int tt = 0; tt < kel[1]; tt++) gav *= 2;
q1 += gav;
break;
}
}
}
}
num[q2] += q1;
return;
}
for (int i = 0; i < 2; i++) nem[x] = i, bctr(x + 1, le);
}
void tap(int x, int y) {
if (x == 6) {
int q5 = 0;
for (int i = 0; i < 6; i++) q5 += hana[i];
if (q5 >= y) return;
int diz[15];
for (int i = 0; i <= 10; i++) diz[i] = num[i];
long long es = 1;
for (int i = 0; i < 6; i++) {
es *= diz[hana[i]];
diz[hana[i]]--;
es %= 1000000007;
}
es *= num[y];
es %= 1000000007;
ans += es;
ans %= 1000000007;
return;
}
for (int j = 0; j < y; j++) {
hana[x] = j;
tap(x + 1, y);
}
}
int main() {
scanf("%d", &n);
dig = 0, k = n;
int ba1 = 0;
while (k > 0) {
arr[dig] = k % 10;
k /= 10;
if (arr[dig] == 4 || arr[dig] == 7) ba1++;
dig++;
}
for (int j = 1; j <= dig; j++) bctr(0, j);
num[ba1]++;
for (int j = 1; j <= 10; j++)
if (num[j] != 0) tap(0, j);
int kel = ans % 1000000007;
printf("%d\n", kel);
getchar();
getchar();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 17;
int n, sx[maxn], sy[maxn], ex[maxn], ey[maxn];
struct bySx {
bool operator()(int i, int j) const {
return sx[i] != sx[j] ? sx[i] < sx[j] : i < j;
}
};
struct bySy {
bool operator()(int i, int j) const {
return sy[i] != sy[j] ? sy[i] < sy[j] : i < j;
}
};
struct byEx {
bool operator()(int i, int j) const {
return ex[i] != ex[j] ? ex[i] > ex[j] : i < j;
}
};
struct byEy {
bool operator()(int i, int j) const {
return ey[i] != ey[j] ? ey[i] > ey[j] : i < j;
}
};
bool solve(set<int, bySx> &&ssx, set<int, bySy> &&ssy, set<int, byEx> &&sex,
set<int, byEy> &&sey) {
if (ssx.size() == 1) return 1;
int bsx, bsy, bex, bey;
auto sxi = ssx.begin();
auto syi = ssy.begin();
auto exi = sex.begin();
auto eyi = sey.begin();
bsx = ex[*sxi];
bsy = ey[*syi];
bex = sx[*exi];
bey = sy[*eyi];
while (sxi != ssx.end()) {
vector<int> cut;
if (bsx <= sx[*sxi]) cut = vector<int>(ssx.begin(), sxi);
if (bsy <= sy[*syi]) cut = vector<int>(ssy.begin(), syi);
if (bex >= ex[*exi]) cut = vector<int>(sex.begin(), exi);
if (bey >= ey[*eyi]) cut = vector<int>(sey.begin(), eyi);
if (cut.size()) {
if (!solve(set<int, bySx>(cut.begin(), cut.end()),
set<int, bySy>(cut.begin(), cut.end()),
set<int, byEx>(cut.begin(), cut.end()),
set<int, byEy>(cut.begin(), cut.end())))
return 0;
for (auto i : cut) {
ssx.erase(i);
ssy.erase(i);
sex.erase(i);
sey.erase(i);
}
if (!solve(move(ssx), move(ssy), move(sex), move(sey))) return 0;
return 1;
}
bsx = max(bsx, ex[*sxi++]);
bsy = max(bsy, ey[*syi++]);
bex = min(bex, sx[*exi++]);
bey = min(bey, sy[*eyi++]);
}
return 0;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> sx[i] >> sy[i] >> ex[i] >> ey[i];
vector<int> all(n);
iota(all.begin(), all.end(), 0);
cout << (solve(set<int, bySx>(all.begin(), all.end()),
set<int, bySy>(all.begin(), all.end()),
set<int, byEx>(all.begin(), all.end()),
set<int, byEy>(all.begin(), all.end()))
? "YES"
: "NO")
<< '\n';
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = int(1e5) + 5;
const int INF = int(1e9) + 7;
const long long MINF = 1e18;
long long ch[int(2e5) + 5];
long long nch[int(2e5) + 5];
long long f[N * 2];
long long s[N * 2];
int main() {
boost();
int n;
cin >> n;
long long a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n; i >= 1; i--) {
if (i % 2 == 0) {
nch[i] = nch[i + 1];
ch[i] = ch[i + 1] + a[i];
} else {
ch[i] = ch[i + 1];
nch[i] = nch[i + 1] + a[i];
}
}
for (int i = 1; i <= n; i++) {
if (i % 2 == 0) {
f[i] = f[i - 1] + a[i];
s[i] = s[i - 1];
} else {
s[i] = s[i - 1] + a[i];
f[i] = f[i - 1];
}
}
int kol = 0;
for (int i = 1; i <= n; i++) {
if (ch[i + 1] + s[i - 1] == nch[i + 1] + f[i - 1]) {
kol++;
}
}
cout << kol;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, i, a = 0, b = 0;
long long x;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%lld", &x);
if (x % 2 == 0) {
a++;
} else {
b++;
}
}
if (a > b) {
printf("%d", b);
} else if (b > a) {
printf("%d", a);
} else {
printf("%d", a);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int test = 1;
while (test--) {
string t, s = "";
cin >> t;
for (int i = 0; i < (t.length()); i++)
if (t[i] != 'a') s += t[i];
string ans = "";
for (int i = 0; i < (t.length() - s.length() / 2); i++) ans += t[i];
int tot = s.length() / 2;
if (s.length() % 2) {
cout << ":(" << endl;
return 0;
}
for (int i = 0; i < (ans.length()); i++) {
if (ans[i] != 'a') {
if (ans[i] != s[tot]) {
cout << ":(" << endl;
return 0;
}
tot++;
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, c, maxbit, a[MAXN];
long long sum[MAXN];
bool check(int x) {
int pos = 1, now = c,
k = lower_bound(a + 1, a + n + 1, x, greater<int>()) - a;
while (pos < k) {
for (int i = maxbit; i >= 0; i--)
if (pos + (1 << i) <= k &&
sum[pos + (1 << i) - 1] - sum[pos - 1] <= now) {
now -= sum[pos + (1 << i) - 1] - sum[pos - 1];
pos += 1 << i;
}
pos = lower_bound(a + pos, a + n + 1, now, greater<int>()) - a;
}
if (now <= x) return false;
now -= x;
pos = lower_bound(a + 1, a + n + 1, now, greater<int>()) - a;
while (pos <= n) {
for (int i = maxbit; i >= 0; i--)
if (pos + (1 << i) - 1 <= n &&
sum[pos + (1 << i) - 1] - sum[pos - 1] <= now) {
now -= sum[pos + (1 << i) - 1] - sum[pos - 1];
pos += 1 << i;
}
pos = lower_bound(a + pos, a + n + 1, now, greater<int>()) - a;
}
return now != 0;
}
int main() {
scanf("%d%d", &c, &n);
while ((1 << maxbit) <= n) maxbit++;
maxbit--;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1, greater<long long>());
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= c; i++)
if (check(i)) {
printf("%d", i);
return 0;
}
printf("Greed is good");
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
long long int power(long long int a, long long int b) {
long long int r = 1;
for (; b; b >>= 1) {
if (b & 1) r = r * a % mod;
a = a * a % mod;
}
return r;
}
using namespace std;
array<int, 4> bitcon(string ans) {
array<int, 4> send = {0, 0, 0, 0};
int i = 0, p = 0;
while (i < int(ans.size())) {
string s1 = "";
int a;
while (i < ans.size() && ans[i] != '.') s1.push_back(ans[i++]);
i++;
a = stoi(s1);
send[p++] = a;
}
return send;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
bool isit = true;
cin >> n >> k;
vector<array<int, 4>> v(n);
string ans = "";
for (int i = 0; i < n; i++) {
cin >> ans;
v[i] = bitcon(ans);
}
array<int, 4> an = {0, 0, 0, 0};
int p;
for (int i = 31; i >= 1; i--) {
for (int i = 0; i < 4; i++) {
if (an[i] == 0) p = 128;
if (an[i] != 255) {
an[i] += p, p /= 2;
break;
}
}
set<array<int, 4>> s;
for (auto it : v) {
array<int, 4> r;
for (int j = 0; j < 4; j++) r[j] = an[j] & it[j];
s.insert(r);
}
if (s.size() == k) {
for (int i = 0; i < 4; i++) cout << an[i] << ". "[i == 3];
return 0;
}
outer:
continue;
}
cout << -1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000, M = 12;
int n, m, cq, a[N + 9][M + 9];
void into() {
scanf("%d%d%d", &n, &m, &cq);
for (int i = 0; i < m; ++i)
for (int j = 1; j <= n; ++j) scanf("%d", &a[j][i]);
}
int ord[N + 9][M + 9];
void Get_ord() {
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < m; ++j) ord[i][j] = j;
sort(ord[i], ord[i] + m,
[&](const int &x, const int &y) { return a[i][x] > a[i][y]; });
}
}
bitset<1 << M> b[N + 9];
int cb;
void Get_b() {
cb = m;
for (int i = 1; i <= m; ++i)
for (int s = 0; s < 1 << m; ++s) b[i][s] = s >> i - 1 & 1;
}
void work() {
Get_ord();
Get_b();
}
void outo() {
for (; cq--;) {
int opt, x, y;
scanf("%d%d%d", &opt, &x, &y);
switch (opt) {
case 1:
b[++cb] = b[x] | b[y];
break;
case 2:
b[++cb] = b[x] & b[y];
break;
case 3:
for (int i = 0, s = 0; i < m; ++i) {
s |= 1 << ord[y][i];
if (b[x][s]) {
printf("%d\n", a[y][ord[y][i]]);
break;
}
}
break;
}
}
}
int main() {
into();
work();
outo();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, l, a[1000009], b[1000009], p[1000009], ans, cn, t, x, y, z,
mx, mn, s, q;
char c[1000009], d[1000009], ch;
int main() {
while (scanf("%d %d", &n, &q) != EOF) {
ans = 0;
x = 1;
y = 2;
for (i = 0; i < q; i++) {
scanf("%d", &t);
if (t == 1) {
scanf("%d", &s);
x += s;
if (x > n) {
x -= n;
}
if (x < 1) {
x += n;
}
y += s;
if (y > n) {
y -= n;
}
if (y < 1) {
y += n;
}
} else {
if (x % 2 == 1) {
x++;
} else {
x--;
}
if (y % 2 == 1) {
y++;
} else {
y--;
}
}
}
a[x] = 1;
z = 3;
i = x + 2;
if (i > n) {
i -= n;
}
if (i < 1) {
i += n;
}
while (i != x) {
a[i] = z;
i += 2;
if (i > n) {
i -= n;
}
if (i < 1) {
i += n;
}
z += 2;
}
a[y] = 2;
z = 4;
i = y + 2;
if (i > n) {
i -= n;
}
if (i < 1) {
i += n;
}
while (i != y) {
a[i] = z;
i += 2;
if (i > n) {
i -= n;
}
if (i < 1) {
i += n;
}
z += 2;
}
for (i = 1; i <= n; i++) {
if (i != 1) {
printf(" ");
}
printf("%d", a[i]);
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int dr[] = {-1, 1, 0, 0};
const int dc[] = {0, 0, -1, 1};
const int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int kr[] = {1, 1, -1, -1, 2, 2, -2, -2};
const int kc[] = {2, -2, 2, -2, 1, -1, 1, -1};
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
void check_time() {}
const int res = 2e5 + 10;
const long long int mod = 1e9 + 7;
int a[res];
void rev(string s, int x, int y) {
int len = s.size();
for (int i = x; i < len / 2; i++) {
swap(s[i], s[len - i - 1]);
if (i == y) {
break;
}
}
}
int main() {
string s;
int n, sum = 0, total, len;
cin >> s;
len = s.size();
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
a[x]++;
}
for (int i = 1; i <= len / 2; i++) {
sum += a[i];
if (sum & 1) {
swap(s[i - 1], s[len - i]);
}
}
cout << s << endl;
check_time();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int ans;
vector<int> guess;
bool prime(int x) {
for (int i = 2; i <= sqrt(x); i++) {
if (x % i == 0) return false;
}
return true;
}
void sol() {
for (int i = 2; i <= n; i++) {
if (prime(i)) {
int j = i;
while (j <= n) {
guess.push_back(j);
ans++;
j *= i;
}
}
}
}
int main() {
cin >> n;
sol();
cout << ans << endl;
for (int j : guess) cout << j << " ";
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int c = 0;
int x, y, a, b;
cin >> x >> y >> a >> b;
if ((y - x) / (a + b) > 0 && (y - x) % (a + b) == 0)
cout << (y - x) / (a + b) << "\n";
else
cout << "-1" << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int n, m, frq[N], dp[N][N][2];
int solve(int num = 0, int sum = 0, bool go = 0) {
if (!sum && go) {
cout << "YES";
exit(0);
}
if (num == m) return 0;
int &ret = dp[num][sum][go];
if (~ret) return ret;
int ans = 0;
for (int i = 0; i <= frq[num]; ++i)
ans |= solve(num + 1, (sum + num * i) % m, i | go);
return ret = ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
memset(dp, -1, sizeof dp);
while (n--) {
int x;
cin >> x;
++frq[x % m];
}
solve();
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
ios ::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n + 1);
int cur_end = n;
int cur_sol = 1;
cout << cur_sol << ' ';
for (int i = 1; i < n; i++) {
int poz;
cin >> poz;
v[poz] = 1;
if (v[cur_end]) {
cur_end--;
while (v[cur_end]) {
cur_end--;
cur_sol--;
}
} else {
cur_sol++;
}
cout << cur_sol << ' ';
}
cout << 1 << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
char str[N];
int l, r, n;
int main() {
scanf("%d %s", &n, str);
if (n < 2 || n % 2 != 0) {
printf(":(\n");
return 0;
}
for (int i = 0; i < n; i += 1) {
if (str[i] == '(')
l += 1;
else if (str[i] == ')')
r += 1;
if (l > n / 2 || r > n / 2) {
printf(":(\n");
return 0;
}
}
for (int i = 0; i < n; i += 1) {
if (str[i] == '?') {
if (l < n / 2) {
str[i] = '(';
l += 1;
} else {
str[i] = ')';
r += 1;
}
}
}
if (r > n / 2) {
printf(":(\n");
return 0;
}
l = r = 0;
for (int i = 0; i < n; i += 1) {
if (str[i] == '(')
l += 1;
else if (str[i] == ')')
--l;
if (l < 0 || (l == 0 && i != n - 1)) {
printf(":(\n");
return 0;
}
}
if (l != 0)
printf(":(\n");
else
printf("%s\n", str);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x, y, z;
cin >> n;
int cnt = 0;
while (n--) {
cin >> x >> y >> z;
if (x + y + z >= 2) {
cnt++;
}
}
cout << cnt << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int q[100001];
int main() {
long long n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> q[i];
while (q[i] % 3 == 0) {
q[i] /= 3;
}
while (q[i] % 2 == 0) {
q[i] /= 2;
}
}
for (int i = 1; i < n; i++) {
if (q[i] != q[n]) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long calc(long long k, long long m) {
if (m == 0) return 1;
if (m == 1) return k % 1000000007;
long long s = calc(k, m / 2);
if (m % 2 == 0) {
return (s * s) % 1000000007;
} else {
long long ans;
ans = (s * s) % 1000000007;
return (k * ans) % 1000000007;
}
}
long long inv[100005], fac[100005], finv[100005];
void make() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (long long i = 2; i < 100005; i++) {
inv[i] = 1000000007 -
(long long)inv[1000000007 % i] * (1000000007 / i) % 1000000007;
fac[i] = (long long)fac[i - 1] * i % 1000000007;
finv[i] = (long long)finv[i - 1] * inv[i] % 1000000007;
}
}
long long comb(long long a, long long b) {
if (a < b) {
return 0;
}
return fac[a] * ((long long)finv[b] * finv[a - b] % 1000000007) % 1000000007;
}
long long ss[100010];
signed main() {
make();
long long n, k;
string s;
cin >> n >> k >> s;
if (k == 0) {
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans *= 10;
ans %= 1000000007;
ans += s[i] - '0';
ans %= 1000000007;
}
cout << ans << endl;
return 0;
}
for (long long i = 0; i < n; i++) {
ss[i] = s[i] - '0';
}
for (long long i = 1; i < n; i++) {
ss[i] += ss[i - 1];
ss[i] %= 1000000007;
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long tmp = 0;
tmp += calc(10, i);
tmp *= ss[n - 2 - i];
tmp %= 1000000007;
tmp *= comb(n - 2 - i, k - 1);
tmp %= 1000000007;
ans += tmp;
ans %= 1000000007;
}
for (long long i = 0; i < n; i++) {
ans += ((s[n - 1 - i] - '0') * comb(n - 1 - i, k) % 1000000007) *
calc(10, i) % 1000000007;
ans %= 1000000007;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int arr[t];
int maxitower = 0;
int largsettower;
int c = 0;
int sumelements = t;
for (int i = 0; i < t; i++) {
cin >> arr[i];
}
for (int s = 0; s < t; s++) {
c = 0;
for (int i = 0; i < t; i++) {
if (arr[s] == arr[i]) {
c++;
}
}
if (maxitower < c) {
maxitower = c;
}
}
cout << maxitower << " ";
int x = 0;
sort(arr, arr + t);
for (int i = 0; i < t; i++) {
if (arr[i] != arr[i + 1]) {
x++;
}
}
cout << x;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long d[1009], g[1009];
long long a1[1009], a2[1009], b1[1009], b2[1009];
void work(long long x, long long n, long long c1[], long long c2[]) {
if (n == 0) {
c1[n] = c2[n] = 0;
return;
}
if (n == 1) {
c1[n] = (x == 2);
c2[n] = (x == 1);
return;
}
if (x <= d[n - 1]) {
work(x, n - 1, c1, c2);
c1[n] = min(c1[n - 1], c2[n - 1] + 2);
c2[n] = min(c1[n - 1], c2[n - 1]) + 1 + g[n - 2];
} else {
work(x - d[n - 1], n - 2, c1, c2);
c1[n] = c1[n - 2] + 1;
c2[n] = c2[n - 2];
}
}
long long dis(long long u, long long v, long long n) {
if (n <= 1) return u != v;
if (u <= d[n - 1]) {
if (v > d[n - 1])
return min(a1[n - 1], a2[n - 1]) + 1 + b1[n - 2];
else
return min(dis(u, v, n - 1),
min(a1[n - 1] + b2[n - 1], a2[n - 1] + b1[n - 1]) + 2);
} else
return dis(u - d[n - 1], v - d[n - 1], n - 2);
}
int main() {
cin >> m >> n;
n = min(n, 1ll * 80);
d[0] = 1;
d[1] = 2;
for (long long i = 2; i <= n; i++) d[i] = d[i - 1] + d[i - 2];
g[0] = 0;
g[1] = g[2] = 1;
for (long long i = 3; i <= n; i++) g[i] = g[i - 2] + 1;
while (m--) {
long long u, v;
scanf("%lld %lld", &u, &v);
if (u > v) swap(u, v);
work(u, n, a1, a2);
work(v, n, b1, b2);
printf("%lld\n", dis(u, v, n));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 9;
long long sum;
int a[N];
int n, k, pre;
bool ismin(int x) {
int t = k;
int mid = lower_bound(a, a + n, x) - a;
for (int i = 0; i < mid; i++) {
t -= (x - a[i]);
if (t < 0) return 0;
}
return 1;
}
bool ismax(int x) {
int t = k;
int mid = upper_bound(a, a + n, x) - a;
for (int i = mid; i < n; i++) {
t -= (a[i] - x);
if (t < 0) return 0;
}
return 1;
}
int main() {
scanf("%d%d", &n, &k);
sum = 0;
for (int i = 0; i < n; i++) scanf("%d", &a[i]), sum += a[i];
sort(a, a + n);
if (a[0] == a[n - 1]) {
printf("0");
return 0;
}
pre = sum / n;
int l = pre, r = a[n - 1];
if (sum % n) l++;
while (l < r) {
int m = l + (r - l) / 2;
if (ismax(m))
r = m;
else
l = m + 1;
}
int maxn = l;
l = a[0], r = pre;
while (l < r) {
int m = l + (r - l + 1) / 2;
if (ismin(m))
l = m;
else
r = m - 1;
}
printf("%d\n", maxn - l);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main(void) {
const double eps = 1e-10;
int i, n, a, d, v, t;
double res1 = 0;
double res2 = 0;
scanf("%d %d %d", &n, &a, &d);
for (i = 0; i < n; i++) {
scanf("%d %d", &t, &v);
if (d + eps - (double)v * v / a / 2.0 < 0) {
res2 = t + sqrt(2.0 * d / a);
if (res1 + eps < res2) {
printf("%lf\n", res2);
res1 = res2;
} else
printf("%lf\n", res1);
} else {
res2 = (d - (double)v * v / a / 2.0) / v + (double)v / a + t;
if (res1 + eps < res2) {
printf("%lf\n", res2);
res1 = res2;
} else
printf("%lf\n", res1);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int input() {
cin >> n;
return 0;
}
int gcd(int p, int q) {
int r;
if (p < q) {
int t = p;
p = q;
q = t;
};
while (1) {
r = p % q;
if (r == 0) break;
p = q;
q = r;
}
return q;
}
int f(int a, int b) {
int t;
if (gcd(a, b) != 1) return -1;
for (int i = 0;; i++) {
if (a < b) {
int t = a;
a = b;
b = t;
};
if (a == 2 && b == 1) return 1 + i;
if (a == 1 && b == 1) return i;
if (a < 1 || b < 1) return -1;
if (a == b) return -1;
if (b == 1) return (a - 1) + i;
t = a - b;
a = b;
b = t;
}
}
int solve() {
int i, min = -1, x;
if (n == 1) return 0;
for (i = n / 2; i; i--) {
x = f(n, i);
if (x == -1) continue;
if (min == -1 || x < min) min = x;
}
return min;
}
int main() {
input();
cout << solve() << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
int px[105], py[105];
int main() {
int x, y, Sz, d, z;
bool f = 0;
string s;
cin >> x >> y >> s;
Sz = s.size();
px[0] = py[0] = 0;
for (int i = 0; i < Sz; i++) {
if (s[i] == 'U')
d = 0;
else if (s[i] == 'D')
d = 1;
else if (s[i] == 'L')
d = 2;
else
d = 3;
px[i + 1] = px[i] + dx[d];
py[i + 1] = py[i] + dy[d];
}
for (int i = 0; i <= Sz; i++) {
if (px[Sz] != 0) z = (x - px[i]) / px[Sz];
if (py[Sz] != 0) z = (y - py[i]) / py[Sz];
if (z < 0) continue;
if (z * px[Sz] == (x - px[i]) && z * py[Sz] == (y - py[i])) f = 1;
}
if (f)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[550000], t[900][900];
void upd(int x, int y) {
a[x] += y;
for (int i = 1; i < 900; i++) t[i][x % i] += y;
}
int calc(int x, int y) {
if (x < 900) return t[x][y];
int ans = 0;
for (int i = y; i <= 500000; i += x) ans += a[i];
return ans;
}
int main() {
ios::sync_with_stdio(0);
int q, opt, x, y;
cin >> q;
while (q--) {
cin >> opt >> x >> y;
if (opt == 1)
upd(x, y);
else
cout << calc(x, y) << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long oo = (1ll << 60);
int gg() {
int x = 0, w = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') w = 0, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return w ? x : -x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
while (T--) {
long long n, i, j, k, l;
cin >> n;
vector<long long> v(n);
for (auto &x : v) cin >> x;
if (n == 1) {
cout << 1 << ' ' << 1 << '\n';
cout << -1 * v[0] << '\n';
cout << 1 << ' ' << 1 << '\n';
cout << 0 << '\n';
cout << 1 << ' ' << 1 << '\n';
cout << 0 << '\n';
return 0;
}
cout << 1 << ' ' << 1 << '\n';
cout << -1 * v[0] << '\n';
cout << 2 << ' ' << n << '\n';
for (i = 1; i < n; i++) {
cout << ((v[i]) % n) * (n - 1) << ' ';
v[i] += (((v[i]) % n) * (n - 1));
}
cout << '\n';
v[0] = 0;
cout << 1 << ' ' << n << '\n';
for (i = 0; i < n; i++) {
cout << -1 * v[i] << ' ';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
scanf("%d %d", &n, &m);
vector<vector<int>> a(n, vector<int>(m, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
vector<vector<int>> b(n, vector<int>(m, 0));
int ans = 0;
int pos = n + m;
vector<int> val(n+m, 0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
val[i+j] ^= a[i][j];
}
}
ans = *max_element(val.begin(), val.end());
puts(ans ? "Ashish" : "Jeel");
}
int main() {
int tc = 1;
scanf("%d", &tc);
while (tc--) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 4 * atan(1);
int N, M;
int tnode[200013], fnode[200013];
bool badv[200013], bade[200013];
bool ans[200013];
int vidx[200013];
int eidx[200013];
int goal[200013];
int A, B;
vector<int> adj[(200013 + 200013)];
int match[(200013 + 200013)];
int dist[(200013 + 200013)];
bool bfs() {
queue<int> q;
memset(dist, -1, sizeof dist);
for (int i = 0; i < A; i++) {
if (match[i] == -1) {
q.push(i);
dist[i] = 0;
}
}
bool reached = false;
while (!q.empty()) {
int n = q.front();
q.pop();
for (int v : adj[n]) {
if (match[v] == -1)
reached = true;
else if (dist[match[v]] == -1) {
dist[match[v]] = dist[n] + 1;
q.push(match[v]);
}
}
}
return reached;
}
bool dfs(int n) {
if (n == -1) return true;
for (int v : adj[n]) {
if (match[v] == -1 || dist[match[v]] == dist[n] + 1) {
if (dfs(match[v])) {
match[v] = n, match[n] = v;
return true;
}
}
}
return false;
}
int hopcroft_karp() {
memset(match, -1, sizeof match);
int matching = 0;
while (bfs()) {
for (int i = 0; i < A; i++)
if (match[i] == -1 && dfs(i)) matching++;
}
return matching;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
memset(tnode, -1, sizeof tnode);
memset(fnode, -1, sizeof fnode);
for (int i = 0; i < N; i++) {
int k;
cin >> k;
for (int j = 0; j < k; j++) {
int x;
cin >> x;
if (x > 0) {
--x;
if (~tnode[x]) {
badv[x] = bade[i] = bade[tnode[x]] = true;
ans[x] = true;
}
tnode[x] = i;
} else {
x = -x;
--x;
if (~fnode[x]) {
badv[x] = bade[i] = bade[fnode[x]] = true;
}
fnode[x] = i;
}
}
}
for (int i = 0; i < M; i++) {
if (~tnode[i] && !~fnode[i]) {
badv[i] = bade[tnode[i]] = true;
ans[i] = true;
} else if (~fnode[i] && !~tnode[i]) {
badv[i] = bade[fnode[i]] = true;
ans[i] = false;
} else if (!~fnode[i] && !~tnode[i]) {
badv[i] = true;
}
}
memset(vidx, -1, sizeof vidx);
memset(eidx, -1, sizeof eidx);
int t = 0;
for (int i = 0; i < M; i++) {
if (!badv[i]) {
vidx[i] = t++;
}
}
A = t;
t = 0;
for (int i = 0; i < N; i++) {
if (!bade[i]) {
eidx[i] = t++;
}
}
B = t;
for (int i = 0; i < M; i++) {
if (!badv[i]) {
if (!bade[tnode[i]]) adj[vidx[i]].push_back(A + eidx[tnode[i]]);
if (!bade[fnode[i]]) adj[vidx[i]].push_back(A + eidx[fnode[i]]);
goal[i] = bade[tnode[i]] ? -1 : A + eidx[tnode[i]];
}
}
int x = hopcroft_karp();
for (int i = 0; i < N; i++) {
x += bade[i];
}
if (x != N) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << '\n';
for (int i = 0; i < M; i++) {
if (!badv[i]) {
ans[i] = match[vidx[i]] == goal[i];
}
cout << ans[i];
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 5e3 + 10;
const int inf = 0x3f3f3f3f;
int fa[maxn], dep[maxn];
bool check(int x) {
while (x % 2 == 0) {
x >>= 1;
}
if (x == 1)
return true;
else
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
dep[1] = 0;
for (int i = (2); i <= (5000); i++) dep[i] = dep[i >> 1] + 1;
while (t--) {
int n, d;
long long ans = 0;
cin >> n >> d;
for (int i = (2); i <= (n); i++) {
fa[i] = (i >> 1);
ans += dep[i];
}
if (ans > d) {
cout << "NO" << '\n';
continue;
}
int now = 1;
while (ans < d && now < n) {
fa[n - now + 1] = n - now;
if (check(n - now + 1)) {
now++;
continue;
}
ans += now;
now++;
}
if (ans < d) {
cout << "NO" << '\n';
continue;
}
if (ans > d) fa[n] = n - (ans - d) - 1;
cout << "YES" << '\n';
for (int i = (2); i <= (n); i++) cout << fa[i] << (i == n ? '\n' : ' ');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 50;
struct Line {
int L, R;
};
Line A[maxn];
int cur = 0;
int n, st, c;
long long dp[2][maxn * 3];
vector<int> temp;
inline int GetPosition(int x) {
return lower_bound(temp.begin(), temp.begin() + c, x) - temp.begin();
}
void initiation() {
scanf("%d%d", &n, &st);
temp.push_back(st);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &A[i].L, &A[i].R);
temp.push_back(A[i].L);
temp.push_back(A[i].R);
}
sort(temp.begin(), temp.end());
c = unique(temp.begin(), temp.end()) - temp.begin();
}
void updata(long long &x, long long v) {
if (~x)
x = min(x, v);
else
x = v;
}
long long solve() {
for (int i = 0; i < c; ++i) dp[cur][i] = abs(temp[i] - st);
for (int i = 1; i <= n; ++i) {
int Lpos = GetPosition(A[i].L);
int Rpos = GetPosition(A[i].R);
for (int j = 0; j < c; ++j) {
if (j <= Rpos && j >= Lpos)
continue;
else if (j > Rpos)
dp[cur][j] += temp[j] - A[i].R;
else
dp[cur][j] += A[i].L - temp[j];
}
int pre = cur;
cur ^= 1;
memset(dp[cur], -1, sizeof(dp[cur]));
long long check = 1LL << 48;
for (int j = 0; j < c; ++j) {
check = min(check, dp[pre][j] - temp[j]);
updata(dp[cur][j], temp[j] + check);
}
check = 1LL << 48;
for (int j = c - 1; j >= 0; --j) {
check = min(check, dp[pre][j] + temp[j]);
updata(dp[cur][j], check - temp[j]);
}
}
long long ans = 1LL << 50;
for (int i = 0; i < c; ++i) ans = min(ans, dp[cur][i]);
return ans;
}
int main(int argc, char *argv[]) {
initiation();
printf("%I64d\n", solve());
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m, k;
cin >> n >> m;
vector<pair<int, int> > pts;
for (i = 0; i < n; i++) {
int p;
cin >> p;
pts.push_back(make_pair(p, i));
}
sort(pts.begin(), pts.end());
vector<pair<int, int> > seg;
for (i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
seg.push_back(make_pair(x, y));
}
sort(seg.begin(), seg.end());
vector<pair<int, int> > ans;
for (i = 0; i < n; i++) {
ans.push_back(make_pair(pts[i].second, i % 2));
}
sort(ans.begin(), ans.end());
for (i = 0; i < n; i++) {
cout << ans[i].second << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const long long int inf = 0x3f3f3f3f3f3f3f3fLL;
long long int i, j, k;
void solve(void);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
int t = 1;
while (t--) solve();
return 0;
}
void solve() {
int n, m;
cin >> n >> m;
set<int> s;
set<pair<long long int, long long int> > v;
unordered_map<int, int> idx;
while (m--) {
int t, id;
cin >> t >> id;
if (t == 1) {
if ((long long)s.size() == 0) {
s.insert(1);
idx[id] = 1;
v.insert(make_pair(n - 1, 1));
} else {
pair<long long int, long long int> temp = *v.rbegin();
auto it = v.lower_bound(make_pair(temp.first, -1));
temp = *it;
auto jt = s.lower_bound(1);
int dis = (*jt) - 1;
if (dis >= temp.first) {
idx[id] = 1;
s.insert(1);
v.insert(make_pair(dis / 2, 1));
} else {
idx[id] = temp.second + temp.first;
v.erase(it);
s.insert(idx[id]);
int d1 = (idx[id] - temp.second) / 2;
v.insert(make_pair(d1, temp.second));
auto jt = s.lower_bound(idx[id] + 1);
int d2;
if (jt == s.end())
d2 = 0;
else
d2 = ((*jt) - idx[id]) / 2;
v.insert(make_pair(d2, idx[id]));
}
}
cout << idx[id] << '\n';
} else {
int k = idx[id];
int d;
auto it = s.lower_bound(k + 1);
if (it == s.end())
d = n - k;
else
d = ((*it) - k) / 2;
auto jt = v.lower_bound(make_pair(d, k));
v.erase(jt);
it = s.lower_bound(k);
if (it != s.begin()) {
--it;
int fin = d + k;
int st = *it;
int dt = (k - st) / 2;
jt = v.lower_bound(make_pair(dt, st));
v.erase(jt);
if (fin == n)
v.insert(make_pair(n - st, st));
else {
it = s.lower_bound(k + 1);
v.insert(make_pair(((*it) - st) / 2, st));
}
}
it = s.lower_bound(k);
s.erase(it);
idx[id] = 0;
}
}
}
| 7 |
#include<bits/stdc++.h>
typedef long long int ll;
using namespace std;
int main(){
int t;
cin>>t;
while(t--){
// code goes here
string s;
cin>>s;
string :: iterator it;
it = s.begin();
int count = 0;
while(it != s.end()){
if(count%2 == 0){
if(*it == 'a') *it = 'b';
else *it = 'a';
}
else{
if(*it == 'z') *it = 'y';
else *it = 'z';
}
count++;
it++;
}
cout<<s<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[(1 << 15) + 10][4][226];
int t[20];
int g[20];
const long long mod = 1000000000 + 7;
long long F[1000];
int siz(int x) {
int tot = 0;
while (x) {
tot += x % 2;
x /= 2;
}
return tot;
}
int main() {
F[0] = 1;
for (int i = 1; i < 1000; i++) F[i] = (F[i - 1] * i % mod);
int n, T;
cin >> n >> T;
for (int i = 1; i <= n; i++) cin >> t[i] >> g[i];
dp[0][0][0] = 1;
for (int j = 0; j < (1 << n); j++) {
for (int i = 1; i <= n; i++) {
if (j & (1 << (i - 1))) continue;
for (int tt = 0; tt <= T - t[i]; tt++) {
for (int gg = 0; gg <= 3; gg++) {
if (gg == g[i]) continue;
(dp[j | (1 << (i - 1))][g[i]][tt + t[i]] += (dp[j][gg][tt] % mod)) %=
mod;
}
}
}
}
long long ans = 0;
for (int i = 1; i < (1 << n); i++) {
for (int tt = T; tt <= T; tt++) {
for (int gg = 1; gg <= 3; gg++) {
(ans += dp[i][gg][tt] % mod) %= mod;
}
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k;
set<int> s;
cin >> n;
int a[n], b[n];
for (i = 0; i < n; i++) cin >> a[i];
k = 0;
for (i = n - 1; i >= 0; i--) {
if (s.count(a[i]) == 0) {
s.insert(a[i]);
b[k] = a[i];
k++;
}
}
cout << k << endl;
for (i = k - 1; i >= 0; i--) cout << b[i] << " ";
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char zf = 1;
char ch = getchar();
while (ch != '-' && !isdigit(ch)) ch = getchar();
if (ch == '-') zf = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * zf;
}
void write(long long y) {
if (y < 0) putchar('-'), y = -y;
if (y > 9) write(y / 10);
putchar(y % 10 + 48);
}
void writeln(const long long y) {
write(y);
putchar('\n');
}
int i, j, k, m, n, x, y, z, cnt;
long long a[200010];
int main() {
n = read() * 2;
for (register int i = 1; i <= n; i++) a[i] = read();
sort(a + 1, a + n + 1);
long long ans = (a[n / 2] - a[1]) * (a[n] - a[n / 2 + 1]);
for (register int i = n / 2; i <= n; i++)
ans = min(ans, (a[n] - a[1]) * (a[i] - a[i - (n / 2) + 1]));
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q = 1;
cin >> q;
while (q--) {
long long n, k;
cin >> n >> k;
long long ans = n;
for (long long i = 1; i * i <= n && i <= k; i++) {
if (n % i == 0) {
if (i <= k) ans = min(ans, (n / i));
if (n / i <= k) ans = min(ans, i);
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, ans = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = 0; i < n; i++) {
if ((sum - a[i]) % 2 == 0) ans++;
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, m;
cin >> n >> m;
string grid[n];
for (string& s : grid) {
cin >> s;
if (s != string(m, s[0])) {
cout << "No\n";
return 0;
}
}
for (long long i = 1; i < n; i++) {
if (grid[i][0] == grid[i - 1][0]) {
cout << "No\n";
return 0;
}
}
cout << "YES\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
getline(cin, s);
int l = s.size();
bool ok = false;
for (int i = 1; i < l; i++)
if (s[i] >= 'a' && s[i] <= 'z') ok = true;
if (!ok) {
for (int i = 0; i < l; i++) {
if (s[i] >= 'A' && s[i] <= 'Z')
s[i] += ('a' - 'A');
else
s[i] -= ('a' - 'A');
}
}
for (int i = 0; i < l; i++) cout << s[i];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> match1, match2;
int num1[200010], ans[200010], num;
long long n, len, m;
void solve(long long l) {
long long r = l + len * (m - 1), i, j, k;
if (r > n) return;
for (i = 0; i < m; i++) {
k = num1[l + i * len];
match1[k]++;
if (match2[k] >= match1[k]) num++;
}
if (num == m) {
ans[0]++;
ans[ans[0]] = l;
}
l += len;
r += len;
while (r <= n) {
k = num1[l - len];
match1[k]--;
if (match2[k] > match1[k]) num--;
k = num1[r];
match1[k]++;
if (match2[k] >= match1[k]) num++;
if (num == m) {
ans[0]++;
ans[ans[0]] = l;
}
l += len;
r += len;
}
}
int main() {
int i, j, k;
scanf("%I64d%I64d%I64d", &n, &m, &len);
for (i = 1; i <= n; i++) scanf("%d", &num1[i]);
for (i = 1; i <= m; i++) {
scanf("%d", &k);
match2[k]++;
}
for (i = 1; i <= len; i++) {
match1.clear();
num = 0;
solve(i);
}
k = ans[0];
sort(ans + 1, ans + 1 + k);
printf("%d\n", k);
if (k > 0) {
printf("%d", ans[1]);
for (i = 2; i <= k; i++) printf(" %d", ans[i]);
}
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, ans = 0, k = 0, flag = 0;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
if (arr[i] == 1 && flag == 0) flag = 1;
if (arr[i] == 0 && flag == 1) k++;
if (arr[i] == 1 && flag == 1) {
ans += k;
k = 0;
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
void Add(int &x, int y) {
if ((x += y) >= P) x -= P;
}
int N, k, R, C, fac[100010];
struct node {
int x, y, z;
} A[60], B[60];
void discretize() {
sort(A + 1, A + k + 1, [](node P, node Q) { return P.x < Q.x; });
for (int i = (1), iend = (k); i <= iend; ++i)
B[i].x = B[i - 1].x + (A[i].x != A[i - 1].x);
for (int i = (1), iend = (k); i <= iend; ++i)
A[i].x = B[i].x, swap(A[i].x, A[i].y);
sort(A + 1, A + k + 1, [](node P, node Q) { return P.x < Q.x; });
for (int i = (1), iend = (k); i <= iend; ++i)
B[i].x = B[i - 1].x + (A[i].x != A[i - 1].x);
for (int i = (1), iend = (k); i <= iend; ++i)
A[i].x = B[i].x, swap(A[i].x, A[i].y);
sort(A + 1, A + k + 1,
[](node P, node Q) { return P.x < Q.x || (P.x == Q.x && P.y < Q.y); });
}
int solve1() {
static int dp[1 << 20], mp[60][60];
for (int i = (1), iend = (k); i <= iend; ++i) mp[A[i].x][A[i].y] = A[i].z;
dp[0] = 1;
for (int i = (1), iend = (R); i <= iend; ++i) {
for (int S = ((1 << C) - 1), Send = (0); S >= Send; --S) {
int x = dp[S];
if (!x) continue;
for (int j = (1), jend = (C); j <= jend; ++j)
if (mp[i][j] && (~S >> (j - 1) & 1)) {
int &z = dp[S | 1 << (j - 1)];
z = (z + 1ll * x * mp[i][j]) % P;
}
}
}
int ans = 0;
for (int S = (0), Send = ((1 << C) - 1); S <= Send; ++S)
Add(ans, 1ll * fac[N - __builtin_popcount(S)] * dp[S] % P);
return ans;
}
int ecnt = 1, h[120], par[120], dp[120][120][2];
bool vis[120], cho[120];
struct edges {
int nxt, to, w;
} E[120];
void addline(int u, int v, int w) { E[++ecnt] = {h[u], v, w}, h[u] = ecnt; }
int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }
void dfs(int u) {
vis[u] = 1, dp[u][0][cho[u]] = 1;
for (int i = h[u]; i; i = E[i].nxt) {
int v = E[i].to;
if (!vis[v]) {
dfs(v);
static int tmp[120][2];
for (int j = (0), jend = (R + C); j <= jend; ++j) {
int x = dp[v][j][0], y = dp[v][j][1];
if (x || y)
for (int k = (0), kend = (R + C); k <= kend; ++k) {
int p = dp[u][k][0], q = dp[u][k][1];
if (p && x) Add(tmp[j + k + 1][1], 1ll * x * p % P * E[i].w % P);
if (p) Add(tmp[j + k][0], 1ll * p * (x + y) % P);
if (q) Add(tmp[j + k][1], 1ll * q * (x + y) % P);
}
}
memcpy(dp[u], tmp, sizeof tmp), memset(tmp, 0, sizeof tmp);
}
}
}
int solve2() {
vector<node> vec;
for (int i = (1), iend = (R + C); i <= iend; ++i) par[i] = i;
for (int i = (1), iend = (k); i <= iend; ++i) {
int u = A[i].x, v = R + A[i].y;
if (find(u) != find(v))
par[find(u)] = find(v), addline(u, v, A[i].z), addline(v, u, A[i].z);
else
vec.push_back(A[i]);
}
int sz = vec.size(), ans = 0;
for (int S = (0), Send = ((1 << sz) - 1); S <= Send; ++S) {
memset(dp, 0, sizeof dp), memset(vis, 0, sizeof vis),
memset(cho, 0, sizeof cho);
int dt = 1, ct = 0;
for (int i = (0), iend = (sz - 1); i <= iend; ++i)
if (S >> i & 1) {
bool &f1 = cho[vec[i].x], &f2 = cho[vec[i].y + R];
if (f1 || f2) dt = 0;
dt = 1ll * dt * vec[i].z % P, f1 = f2 = 1, ct++;
}
int lsj[120], tmp[120];
memset(lsj, 0, sizeof lsj), memset(tmp, 0, sizeof tmp), lsj[0] = 1;
for (int u = (1), uend = (R + C); u <= uend; ++u)
if (!vis[u]) {
dfs(u);
for (int i = (0), iend = (R + C); i <= iend; ++i) {
int x = (dp[u][i][0] + dp[u][i][1]) % P;
if (x)
for (int j = (0), jend = (R + C); j <= jend; ++j)
Add(tmp[i + j], 1ll * x * lsj[j] % P);
}
memcpy(lsj, tmp, sizeof tmp), memset(tmp, 0, sizeof tmp);
}
for (int i = (0), iend = (R + C); i <= iend; ++i)
ans = (ans + 1ll * dt * fac[N - (ct + i)] % P * lsj[i]) % P;
}
return ans;
}
int main() {
cin >> N >> k;
fac[0] = 1;
for (int i = (1), iend = (N); i <= iend; ++i)
fac[i] = 1ll * i * fac[i - 1] % P;
for (int i = (1), iend = (k); i <= iend; ++i)
cin >> A[i].x >> A[i].y >> A[i].z, A[i].z = (P - 1 + A[i].z) % P;
discretize();
for (int i = (1), iend = (k); i <= iend; ++i)
R = max(R, A[i].x), C = max(C, A[i].y);
if (R < C) {
swap(R, C);
for (int i = (1), iend = (k); i <= iend; ++i) swap(A[i].x, A[i].y);
}
printf("%d\n", C <= 20 ? solve1() : solve2());
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 5, blSize = 400;
int N, arr[maxN];
int block[blSize][maxN];
int s[blSize], e[blSize];
int blockAns[maxN];
int temp[maxN];
int tempAns;
int rep[maxN];
void tempAdd(int x, int val) {
tempAns -= temp[x] > 0;
temp[x] += val;
tempAns += temp[x] > 0;
}
void solve(int k) {
int e = 0;
for (int i = (int)1; i <= (int)N; i++) {
tempAdd(arr[i], 1);
tempAdd(arr[i + 1], 1);
if (tempAns > k or i == N) {
for (int j = (int)i; j >= (int)e + 1; j--) tempAdd(arr[j], -1);
e = i;
rep[k]++;
}
tempAdd(arr[i + 1], -1);
}
}
void blockAdd(int bl, int x, int val) {
blockAns[bl] -= block[bl][x] > 0;
block[bl][x] += val;
blockAns[bl] += block[bl][x] > 0;
}
void solve2(int k) {
for (int bl = (int)0; bl <= (int)blSize - 1; bl++) {
if (bl) {
while (s[bl] <= e[bl - 1] and s[bl] <= N) blockAdd(bl, arr[s[bl]++], -1);
while (e[bl] < s[bl] and e[bl] <= N) blockAdd(bl, arr[++e[bl]], 1);
}
while (e[bl] < N) {
blockAdd(bl, arr[e[bl] + 1], 1);
if (blockAns[bl] <= k)
e[bl]++;
else {
blockAdd(bl, arr[e[bl] + 1], -1);
break;
}
}
if (e[bl] == N) rep[k] = bl + 1;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> N;
for (int i = (int)1; i <= (int)N; i++) cin >> arr[i];
for (int k = (int)1; k <= (int)N; k++) {
if (k <= blSize)
solve(k);
else
solve2(k);
cout << rep[k] << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x;
int y;
Point(int x = 0, int y = 0) {
this->x = x;
this->y = y;
}
};
Point points1[6];
Point points2[6];
bool cmp(Point a, Point b) {}
int GetCross(Point& p1, Point& p2, Point& p) {
return (p2.x - p1.x) * (p.y - p1.y) - (p.x - p1.x) * (p2.y - p1.y);
}
bool IsPointInMatrix(Point& p, int x) {
Point p1;
Point p2;
Point p3;
Point p4;
Point p5;
if (x == 1) {
p1 = points2[1];
p2 = points2[2];
p3 = points2[3];
p4 = points2[4];
} else {
p1 = points1[1];
p2 = points1[2];
p3 = points1[3];
p4 = points1[4];
}
return GetCross(p1, p2, p) * GetCross(p3, p4, p) >= 0 &&
GetCross(p2, p3, p) * GetCross(p4, p1, p) >= 0;
}
int main() {
int up1 = -101;
int up2 = -101;
int do1 = 101;
int do2 = 101;
int le1 = 101;
int le2 = 101;
int ri1 = -101;
int ri2 = -101;
for (int i = 1; i <= 4; ++i) {
cin >> points1[i].x >> points1[i].y;
up1 = max(up1, points1[i].y);
do1 = min(do1, points1[i].y);
le1 = min(le1, points1[i].x);
ri1 = max(ri1, points1[i].x);
}
int b;
for (int i = 1; i <= 4; ++i) {
cin >> points2[i].x >> points2[i].y;
up2 = max(up2, points2[i].y);
do2 = min(do2, points2[i].y);
le2 = min(le2, points2[i].x);
ri2 = max(ri2, points2[i].x);
b = points2[i].y - points2[i].x;
}
int sign = 0;
for (int i = 1; i <= 4; ++i) {
if (IsPointInMatrix(points1[i], 1)) {
sign = 1;
break;
}
}
for (int i = 1; i <= 4; ++i) {
if (IsPointInMatrix(points2[i], 2)) {
sign = 1;
break;
}
}
if (sign == 1 || ((le1 + b - up1) * (ri1 + b - do1) < 0 && le2 < le1 &&
ri2 > le1 && up1 < up2))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int t;
while (a > 0) t = b % a, b = a, a = t;
return b;
}
int t[200000], x[200000], y[200000];
vector<long long int> poss;
vector<pair<int, int> > points[200000];
map<pair<int, int>, int> M;
int main() {
int i;
int q;
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%d %d %d", &t[i], &x[i], &y[i]);
if (t[i] == 1)
poss.push_back((long long int)x[i] * x[i] + (long long int)y[i] * y[i]);
}
sort(poss.begin(), poss.end());
poss.resize(unique(poss.begin(), poss.end()) - poss.begin());
int j, num = 0;
for (i = 0; i < q; i++) {
if (t[i] == 1) {
int p =
lower_bound(poss.begin(), poss.end(),
(long long int)x[i] * x[i] + (long long int)y[i] * y[i]) -
poss.begin();
points[p].push_back(make_pair(x[i], y[i]));
for (j = 0; j < points[p].size(); j++) {
int xx = points[p][j].first + x[i];
int yy = points[p][j].second + y[i];
int g = gcd(xx, yy);
xx /= g, yy /= g;
M[make_pair(xx, yy)] += (j == points[p].size() - 1) ? 1 : 2;
}
num++;
} else if (t[i] == 2) {
int p =
lower_bound(poss.begin(), poss.end(),
(long long int)x[i] * x[i] + (long long int)y[i] * y[i]) -
poss.begin();
int q = find(points[p].begin(), points[p].end(), make_pair(x[i], y[i])) -
points[p].begin();
swap(points[p].back(), points[p][q]);
for (j = 0; j < points[p].size(); j++) {
int xx = points[p][j].first + x[i];
int yy = points[p][j].second + y[i];
int g = gcd(xx, yy);
xx /= g, yy /= g;
M[make_pair(xx, yy)] -= (j == points[p].size() - 1) ? 1 : 2;
if (M[make_pair(xx, yy)] == 0) M.erase(make_pair(xx, yy));
}
points[p].pop_back();
num--;
} else {
int g = gcd(x[i], y[i]);
x[i] /= g, y[i] /= g;
printf("%d\n", num - M[make_pair(x[i], y[i])]);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
pair<pair<int, int>, int> edges[MAXN];
unordered_set<int> col[MAXN];
unordered_map<int, int> par[MAXN];
unordered_map<long long, int> mp;
int find(int c, int x) {
if (x == par[c][x]) return x;
return par[c][x] = find(c, par[c][x]);
}
bool join(int c, int a, int b) {
a = find(c, a);
b = find(c, b);
if (a == b) return false;
par[c][a] = b;
return true;
}
bool isconn(int c, int a, int b) { return find(c, a) == find(c, b); }
int main() {
int N, M;
scanf("%d %d", &N, &M);
for (int i = 0; i < M; ++i) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a, --b, --c;
edges[i] = make_pair(make_pair(a, b), c);
col[a].insert(c);
col[b].insert(c);
par[c][a] = a;
par[c][b] = b;
}
for (int i = 0; i < M; ++i) {
join(edges[i].second, edges[i].first.first, edges[i].first.second);
}
int Q;
scanf("%d", &Q);
for (int i = 0; i < Q; ++i) {
int a, b;
scanf("%d %d", &a, &b);
--a, --b;
if (mp.count((long long)MAXN * a + b)) {
printf("%d\n", mp[(long long)MAXN * a + b]);
continue;
}
int cnt = 0;
if (col[a].size() > col[b].size()) swap(a, b);
for (int x : col[a]) {
if (col[b].count(x)) {
cnt += isconn(x, a, b);
}
}
mp[(long long)MAXN * a + b] = cnt;
mp[(long long)MAXN * b + a] = cnt;
printf("%d\n", cnt);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
node* next[26];
inline node() { memset(next, 0, sizeof(next)); }
};
node* root;
inline void insert(node* x, char* str) {
int len = (int)strlen(str);
for (int i = 0; i < len; ++i) {
int c = str[i] - 'a';
if (!x->next[c]) {
x->next[c] = new (node);
}
x = x->next[c];
}
}
int const N = 1e6 + 10;
int n, k;
inline bool dfs1(node* x) {
for (int i = 0; i < 26; ++i) {
if (x->next[i]) {
if (!dfs1(x->next[i])) {
return true;
}
}
}
return false;
}
inline bool dfs2(node* x, int turn) {
if (turn == 0) {
bool in = false;
for (int i = 0; i < 26; ++i) {
if (x->next[i]) {
in = true;
if (dfs2(x->next[i], turn ^ 1)) {
return true;
}
}
}
if (!in) {
return true;
} else {
return false;
}
} else {
bool in = false;
for (int i = 0; i < 26; ++i) {
if (x->next[i]) {
in = true;
if (!dfs2(x->next[i], turn ^ 1)) {
return false;
}
}
}
if (!in) {
return false;
} else {
return true;
}
}
}
int main() {
scanf("%d%d", &n, &k);
root = new (node);
for (int i = 1; i <= n; ++i) {
static char buffer[N];
scanf("%s", buffer);
insert(root, buffer);
}
bool first_can_win = dfs1(root);
bool first_can_let_second_win = dfs2(root, 0);
if (first_can_win) {
if (first_can_let_second_win) {
puts("First");
} else {
if (k % 2 == 1) {
puts("First");
} else {
puts("Second");
}
}
} else {
puts("Second");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
long long int binarysearch(long long int a[], long long int val,
long long int n) {
long long int l = 0;
long long int r = n - 1;
long long int pos = abs(val);
long long int mid;
while (l < r) {
mid = (l + r) / 2;
if (a[mid] > pos)
r = mid;
else
l = mid;
if (r - l == 1) break;
}
if (a[l] > pos)
return n - l;
else if (a[r] > pos)
return n - r;
else
return 0;
}
void answer(long long int n, long long int a[]) {
if (a[n / 2] == 9) {
a[n / 2] = 0;
for (long long int i = n / 2 - 1; i >= 0; i--) {
if (i == 0 && a[i] == 9) {
a[i]++;
break;
}
if (a[i] == 9) {
a[i] = 0;
continue;
} else {
a[i]++;
break;
}
}
}
for (long long int i = 0; i <= n / 2; i++) {
cout << a[i] << " ";
}
for (long long int i = n / 2 - 1; i >= 0; i--) cout << a[i] << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
if (n % 2 == 0)
cout << 4 + n << " " << 4;
else
cout << 9 + n << " " << 9;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char dir;
string s;
cin >> dir;
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (dir == 'L') {
if (s[i] == 'q') cout << 'w';
if (s[i] == 'w') cout << 'e';
if (s[i] == 'e') cout << 'r';
if (s[i] == 'r') cout << 't';
if (s[i] == 't') cout << 'y';
if (s[i] == 'y') cout << 'u';
if (s[i] == 'u') cout << 'i';
if (s[i] == 'i') cout << 'o';
if (s[i] == 'o') cout << 'p';
if (s[i] == 'p') continue;
if (s[i] == 'a') cout << 's';
if (s[i] == 's') cout << 'd';
if (s[i] == 'd') cout << 'f';
if (s[i] == 'f') cout << 'g';
if (s[i] == 'g') cout << 'h';
if (s[i] == 'h') cout << 'j';
if (s[i] == 'j') cout << 'k';
if (s[i] == 'k') cout << 'l';
if (s[i] == 'l') cout << ';';
if (s[i] == ';') continue;
if (s[i] == 'z') cout << 'x';
if (s[i] == 'x') cout << 'c';
if (s[i] == 'c') cout << 'v';
if (s[i] == 'v') cout << 'b';
if (s[i] == 'b') cout << 'n';
if (s[i] == 'n') cout << 'm';
if (s[i] == 'm') cout << ',';
if (s[i] == ',') cout << '.';
if (s[i] == '.') cout << '/';
if (s[i] == '/') continue;
}
if (dir == 'R') {
if (s[i] == 'q') continue;
if (s[i] == 'w') cout << 'q';
if (s[i] == 'e') cout << 'w';
if (s[i] == 'r') cout << 'e';
if (s[i] == 't') cout << 'r';
if (s[i] == 'y') cout << 't';
if (s[i] == 'u') cout << 'y';
if (s[i] == 'i') cout << 'u';
if (s[i] == 'o') cout << 'i';
if (s[i] == 'p') cout << 'o';
if (s[i] == 'a') continue;
if (s[i] == 's') cout << 'a';
if (s[i] == 'd') cout << 's';
if (s[i] == 'f') cout << 'd';
if (s[i] == 'g') cout << 'f';
if (s[i] == 'h') cout << 'g';
if (s[i] == 'j') cout << 'h';
if (s[i] == 'k') cout << 'j';
if (s[i] == 'l') cout << 'k';
if (s[i] == ';') cout << 'l';
if (s[i] == 'z') continue;
if (s[i] == 'x') cout << 'z';
if (s[i] == 'c') cout << 'x';
if (s[i] == 'v') cout << 'c';
if (s[i] == 'b') cout << 'v';
if (s[i] == 'n') cout << 'b';
if (s[i] == 'm') cout << 'n';
if (s[i] == ',') cout << 'm';
if (s[i] == '.') cout << ',';
if (s[i] == '/') cout << '.';
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], q, ans[200005], root[200005], len[200005];
int cidx[200005], hang[200005];
long long m[200005];
basic_string<int> inv[200005], qry[200005];
basic_string<int> root_inv[200005], occ[200005], hang_inv[200005];
bool st[200005], cyc[200005];
void dfs1(int x) {
int y = a[x];
st[x] = 1;
if (root[y]) {
root[x] = root[y];
} else if (st[y]) {
root[x] = x;
} else {
dfs1(y);
root[x] = root[y];
}
st[x] = 0;
}
int el[200005], er[200005], et, dub[200005];
void dfs2(int x, int h) {
el[x] = et++;
hang[x] = h;
hang_inv[h] += x;
for (int y : inv[x]) {
if (!cyc[y]) {
dub[y] = dub[x] + 1;
dfs2(y, h);
}
}
er[x] = et;
}
struct ads {
int sz, l;
deque<int> w;
ads(int sz, int l) : sz(sz), l(l), w(sz) {}
void add(int x) { w[x]++; }
void prepare() {
for (int i = l; i < sz; i++) w[i] += w[i - l];
}
void extend() {
w.push_front(0);
sz++;
}
void wrap(int x) { w[x]++; }
int get(long long x) {
if (x >= sz) x -= (x - sz) / l * l + l;
return w[x];
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
inv[a[i]] += i;
}
cin >> q;
for (int i = 0; i < q; i++) {
int y;
cin >> m[i] >> y;
qry[y] += i;
}
for (int i = 1; i <= n; i++)
if (!root[i]) dfs1(i);
for (int i = 1; i <= n; i++) root_inv[root[i]] += i;
for (int i = 1; i <= n; i++) {
if (i == root[i]) {
int l = 1;
cyc[i] = 1;
for (int j = a[i]; j != i; j = a[j]) {
cidx[j] = l;
l++;
cyc[j] = 1;
}
len[i] = l;
}
}
for (int i = 1; i <= n; i++) {
if (cyc[i]) {
dfs2(i, i);
}
}
for (int i = 1; i <= n; i++) {
occ[dub[i]] += el[i];
}
for (int i = 0; i <= n; i++) sort(occ[i].begin(), occ[i].end());
for (int x = 1; x <= n; x++) {
if (!cyc[x]) {
for (int i : qry[x]) {
int d = min(200001ll, m[i] + dub[x]);
auto it1 = lower_bound(occ[d].begin(), occ[d].end(), el[x]);
auto it2 = lower_bound(occ[d].begin(), occ[d].end(), er[x]);
ans[i] = it2 - it1;
}
}
}
for (int x = 1; x <= n; x++) {
if (x == root[x]) {
int sz = root_inv[x].size(), l = len[x];
ads w(sz, l);
for (int y : root_inv[x]) {
int h = hang[y];
w.add(dub[y] + (cidx[h] == 0 ? 0 : l - cidx[h]));
}
w.prepare();
for (int _i = 0, y = x; _i < l; _i++) {
for (int i : qry[y]) {
ans[i] = w.get(m[i]);
}
y = a[y];
w.extend();
for (int z : hang_inv[y]) {
w.wrap(dub[z]);
}
}
}
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int father(pair<long long int, long long int> dsu[],
long long int v) {
if (dsu[v].first == v) {
return v;
} else {
return dsu[v].first = father(dsu, dsu[v].first);
}
}
void solve() {
long long int sl, i, j;
char second[10000];
cin >> second;
for (sl = 0; second[sl] != 0; sl++)
;
vector<bool> is_prime(sl + 1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; i * i <= sl; i++) {
if (is_prime[i]) {
for (int j = i * i; j <= sl; j += i) is_prime[j] = false;
}
}
map<char, long long int> make_pair;
for (i = 0; i < sl; i++) {
if (make_pair.count(second[i])) {
make_pair[second[i]] += 1;
} else {
make_pair[second[i]] = 1;
}
}
pair<long long int, long long int> dsu[sl];
for (i = 0; i < sl; i++) {
dsu[i].first = i;
dsu[i].second = 1;
}
for (i = 0; i < sl; i++) {
for (j = 2; j <= sl; j++) {
if (is_prime[j]) {
if ((i + 1) % j == 0) {
long long int f1 = father(dsu, i);
long long int f2 = father(dsu, j - 1);
if (f1 == f2) {
} else {
dsu[f1].first = f2;
dsu[f2].second += dsu[f1].second;
}
}
}
}
}
set<pair<long long int, char>> letters;
set<pair<long long int, char>>::iterator it;
set<pair<long long int, long long int>> tree_length;
for (i = 0; i < sl; i++) {
if (father(dsu, i) == i) {
tree_length.insert({-dsu[i].second, i});
}
letters.insert({make_pair[second[i]], second[i]});
}
for (auto y : tree_length) {
it = letters.lower_bound({-y.first, 'a'});
if (it == letters.end()) {
cout << "NO" << endl;
return;
} else {
long long int c = it->first;
second[y.second] = it->second;
letters.erase(it);
if (c - y.first > 0) letters.insert({c + y.first, second[y.second]});
}
}
cout << "YES" << endl;
for (i = 0; i < sl; i++) {
long long int f1 = father(dsu, i);
second[i] = second[f1];
}
cout << second << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20;
int n, m, ans;
char c[MAXN][MAXN];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> c[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
bool k = false;
for (int a = -1; a < 2; a++) {
if (k) break;
for (int b = -1; b < 2; b++)
if ((a + b) % 2 && c[i][j] == 'W' && c[i + a][j + b] == 'P') {
ans++;
k = true;
break;
}
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 222;
int n, m, a[N];
double p[N][N][N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i <= m; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
p[i][j][k] = 0.0;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (a[i] < a[j]) {
p[0][i][j] = 1.0;
} else {
p[0][j][i] = 1.0;
}
}
}
double d = 2.0 / (1.0 * n * (n + 1));
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
int x = j;
int y = k;
if (l <= x && x <= r) {
x = l + r - x;
}
if (l <= y && y <= r) {
y = l + r - y;
}
p[i + 1][x][y] += p[i][j][k] * d;
}
}
}
}
}
double ans = 0.0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans += p[m][j][i];
}
}
printf("%.15f\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int col[100005][2], par[100005];
int t[100005][2];
int vis[100005];
vector<vector<int> > adj;
vector<int> P, Q;
int N, M, K;
int ctr;
void init() {
for (int i = 0; i <= N; ++i) par[i] = i;
}
int find(int u) { return (par[u] == u ? u : (par[u] = find(par[u]))); }
void dfs(int u) {
vis[u] = 1;
t[u][0] = ctr++;
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (vis[v]) continue;
dfs(v);
}
t[u][1] = ctr++;
}
int main() {
int type, u, v;
K = 1;
scanf("%d %d", &N, &M);
adj = vector<vector<int> >(N + 3);
init();
for (int i = 0; i < M; ++i) {
scanf("%d", &type);
if (type == 1) {
scanf("%d %d", &u, &v);
par[find(u)] = v;
adj[u].push_back(v);
adj[v].push_back(u);
} else if (type == 2) {
scanf("%d", &u);
col[K][0] = u;
col[K][1] = find(u);
++K;
} else if (type == 3) {
scanf("%d %d", &u, &v);
P.push_back(u);
Q.push_back(v);
}
}
ctr = 0;
for (int i = 1; i <= N; ++i) {
if (par[i] == i) {
dfs(i);
}
}
for (int i = 0; i < P.size(); ++i) {
u = col[Q[i]][0];
v = col[Q[i]][1];
if (t[u][0] >= t[P[i]][0] && t[P[i]][1] >= t[u][1] &&
t[v][0] <= t[P[i]][0] && t[P[i]][1] <= t[v][1]) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n + n / 2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int bfs(string a, int n, int k) {
queue<string> q;
map<string, int> m;
m[a] = 1;
q.push(a);
int count = a.length();
int ans = 1;
while (!q.empty()) {
string s = q.front();
q.pop();
int x = 0;
while (x < s.length()) {
string curr = "";
for (int i = 0; i < s.length(); i++) {
if (i != x) curr += s[i];
}
if (m.find(curr) == m.end()) {
q.push(curr);
m[curr] = 1;
count += curr.length();
ans++;
if (ans == k) return n * k - count;
}
x++;
}
}
return -1;
}
int main() {
int n, k;
cin >> n >> k;
string a;
cin >> a;
if (k == 1)
cout << 0 << endl;
else
cout << bfs(a, n, k);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int prime(long long int n) {
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) return i;
}
return -1;
}
void solve() {
long long int n, s, ppr, d;
cin >> n;
s = n;
ppr = n;
while (ppr != 1) {
d = prime(ppr);
if (d == -1)
ppr = 1;
else
ppr = ppr / d;
s += ppr;
}
cout << s << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
for (long long int tt = 1; tt < t + 1; tt++) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
auto random_address = [] {
char *p = new char;
delete p;
return (uint64_t)p;
};
struct safe_hash32 {
static unsigned hash32(unsigned x) {
x = (x ^ (x >> 16)) * 0x45d9f3b;
x = (x ^ (x >> 16)) * 0x45d9f3b;
return x ^ (x >> 16);
}
unsigned operator()(unsigned x) const {
static const unsigned FIXED_RANDOM =
hash32(chrono::steady_clock::now().time_since_epoch().count() *
(random_address() | 1));
return hash32(x ^ FIXED_RANDOM);
}
};
using hash_t = uint8_t;
const int INF = 1e9 + 5;
struct lecture {
int start, end, index;
bool operator<(const lecture &other) const {
return make_pair(start, end) < make_pair(other.start, other.end);
}
};
int N;
vector<lecture> A, B;
vector<hash_t> hash_value;
vector<hash_t> compute_hashes(vector<lecture> lectures) {
sort(lectures.begin(), lectures.end());
vector<hash_t> prefix_sums(N + 1, 0);
for (int i = 0; i < N; i++)
prefix_sums[i + 1] = prefix_sums[i] + hash_value[lectures[i].index];
vector<hash_t> answers(N, 0);
vector<hash_t> changes(N + 1, 0);
for (int i = 0; i < N; i++) {
int end = lower_bound(lectures.begin(), lectures.end(),
(lecture){lectures[i].end, INF, -1}) -
lectures.begin();
answers[i] += prefix_sums[end] - prefix_sums[i + 1];
changes[i + 1] += hash_value[lectures[i].index];
changes[end] -= hash_value[lectures[i].index];
}
hash_t sum = 0;
for (int i = 0; i < N; i++) {
sum += changes[i];
answers[i] += sum;
}
vector<hash_t> reordered(N);
for (int i = 0; i < N; i++) reordered[lectures[i].index] = answers[i];
return reordered;
}
bool check() { return compute_hashes(A) == compute_hashes(B); }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
A.resize(N);
B.resize(N);
for (int i = 0; i < N; i++) {
cin >> A[i].start >> A[i].end >> B[i].start >> B[i].end;
A[i].index = B[i].index = i;
}
hash_value.assign(N, 0);
for (int i = 0; i < N; i++) hash_value[i] = safe_hash32()(i);
cout << (check() ? "YES" : "NO") << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
const long double eps = 1e-6;
long long n;
long double ans = 1e12;
vector<pair<long double, long long> > vec;
struct Point {
long double x, y;
Point(long double x = 0, long double y = 0) : x(x), y(y) {}
Point operator+(const Point& rhs) const {
return Point(x + rhs.x, y + rhs.y);
}
Point operator-(const Point& rhs) const {
return Point(x - rhs.x, y - rhs.y);
}
Point operator*(const long double& val) const {
return Point(x * val, y * val);
}
Point operator/(const long double& val) const {
return Point(x / val, y / val);
}
long double dist(const Point& rhs) {
return sqrtl((x - rhs.x) * (x - rhs.x) + (y - rhs.y) * (y - rhs.y));
}
long double distpw2(const Point& rhs) {
return (x - rhs.x) * (x - rhs.x) + (y - rhs.y) * (y - rhs.y);
}
Point norm(const long double& val) {
return Point(x * val / dist(Point()), y * val / dist(Point()));
}
long double ccw(const Point& rhs1, const Point& rhs2) {
return (rhs1.x - x) * (rhs2.y - y) - (rhs2.x - x) * (rhs1.y - y);
}
long long signccw(const Point& rhs1, const Point& rhs2) {
return ccw(rhs1, rhs2) >= 0 ? 1 : -1;
}
} p1, p2, middle, p3;
struct Circle {
Point cen;
long double r;
Circle(Point cen = Point(), long double r = 0) : cen(cen), r(r) {}
bool in(const Circle& rhs) { return cen.dist(rhs.cen) + r <= rhs.r; }
bool out(const Circle& rhs) { return cen.dist(rhs.cen) >= r + rhs.r; }
bool intersect(Circle rhs) { return !in(rhs) && !out(rhs) && !rhs.in(*this); }
} c[N + 5], minn;
void solve(Circle jud) {
long double l = -1e12, r = 1e12;
long long sign = p1.signccw(p2, jud.cen);
while (r - l > eps) {
long double mid = (l + r) / 2;
Circle cmid =
Circle(middle + p3.norm(mid), sqrt(minn.r * minn.r + mid * mid));
if (cmid.intersect(jud) || jud.in(cmid)) {
if (sign == 1)
r = mid;
else
l = mid;
} else {
if (sign == -1)
r = mid;
else
l = mid;
}
}
vec.push_back({l, -sign});
l = -1e12, r = 1e12;
while (r - l > eps) {
long double mid = (l + r) / 2;
Circle cmid =
Circle(middle + p3.norm(mid), sqrt(minn.r * minn.r + mid * mid));
if (cmid.out(jud) || cmid.intersect(jud)) {
if (sign == 1)
l = mid;
else
r = mid;
} else {
if (sign == -1)
l = mid;
else
r = mid;
}
}
vec.push_back({l, sign});
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> p1.x >> p1.y >> p2.x >> p2.y;
middle = p1 + (p2 - p1) / 2;
p3 = Point(p2.y - p1.y, p1.x - p2.x);
p3 = p3 * -1;
cin >> n;
for (long long i = 1; i <= n; ++i) cin >> c[i].cen.x >> c[i].cen.y >> c[i].r;
minn = Circle(middle, p1.dist(p2) / 2);
bool okMinn = 1;
for (long long i = 1; i <= n; ++i)
if (minn.intersect(c[i])) {
okMinn = 0;
break;
}
if (okMinn) {
cout << minn.r;
return 0;
}
for (long long i = 1; i <= n; ++i) solve(c[i]);
sort(vec.begin(), vec.end());
long long cur = 0;
for (auto i : vec) {
if (cur >= 0) {
ans = min(ans, sqrt(i.first * i.first + minn.r * minn.r));
}
cur += i.second;
if (cur >= 0) {
ans = min(ans, sqrt(i.first * i.first + minn.r * minn.r));
}
}
cout << ans;
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimze("Ofast")
using namespace std;
const long long infl = 0x3f3f3f3f3f3f3f3fLL;
const long long infi = 0x3f3f3f3f;
const long long mod = 998244353;
const long long N = 2e5 + 5;
void solve() {
long long n, p, w, d;
cin >> n >> p >> w >> d;
long long x = infl, y = infl;
for (long long i = 0; i <= w - 1; i++) {
if (p - i * d >= 0 && (p - i * d) % w == 0) {
y = i;
x = (p - i * d) / w;
break;
}
}
if (x + y <= n) {
cout << x << " " << y << " " << n - x - y;
} else
cout << -1;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
long long t = 1;
while (t--) solve();
return 0;
}
long long powm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long divide(long long a, long long b) {
return ((a % mod) * powm(b, mod - 2)) % mod;
}
long long mul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long add(long long a, long long b) { return (a % mod + b % mod) % mod; }
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[100000 + 9];
int b[100000 + 9];
int seg[4 * 100000 + 9];
int lazy[4 * 100000 + 9];
void make_tree(int n, int l, int r) {
if (l == r) {
seg[n] = 1000000001;
lazy[n] = 1000000001;
return;
}
int m = l + r >> 1;
make_tree(2 * n, l, m);
make_tree(2 * n + 1, m + 1, r);
lazy[n] = 1000000001;
seg[n] = 1000000001;
}
void update(int n, int l, int r, int L, int R, int val) {
if (lazy[n] != 1000000001) {
seg[n] = lazy[n];
if (l != r) {
lazy[2 * n] = lazy[n];
lazy[2 * n + 1] = lazy[n];
}
lazy[n] = 1000000001;
}
if (r < L || R < l) {
return;
}
if (l >= L && r <= R) {
seg[n] = val;
if (l != r) {
lazy[2 * n] = val;
lazy[2 * n + 1] = val;
}
return;
}
int m = l + r >> 1;
update(2 * n, l, m, L, R, val);
update(2 * n + 1, m + 1, r, L, R, val);
return;
}
int query(int n, int l, int r, int x) {
if (lazy[n] != 1000000001) {
seg[n] = lazy[n];
if (l != r) {
lazy[2 * n] = lazy[n];
lazy[2 * n + 1] = lazy[n];
}
lazy[n] = 1000000001;
}
if (l == r) {
return seg[n];
}
int m = l + r >> 1;
if (x <= m) {
return query(2 * n, l, m, x);
} else {
return query(2 * n + 1, m + 1, r, x);
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
make_tree(1, 1, n);
for (int i = 1; i <= m; i++) {
int t, x, y, k;
scanf("%d%d", &t, &x);
if (t == 1) {
scanf("%d%d", &y, &k);
update(1, 1, n, y, y + k - 1, x - y);
} else {
int ans = query(1, 1, n, x);
if (ans != 1000000001) {
printf("%d\n", a[x + ans]);
} else {
printf("%d\n", b[x]);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double PI = 3.1415926535897932384626;
vector<long long> arr(200005);
vector<long long> perm(200005);
vector<long long> parent(200005, -1);
vector<long long> sum(200005);
vector<long long> sz(200005);
long long find_set(long long v) {
if (parent[v] == -1) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(long long a, long long b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (sz[b] > sz[a]) swap(a, b);
sz[a] += sz[b];
sum[a] += sum[b];
parent[b] = a;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> arr[i];
for (long long i = 0; i < n; i++) {
cin >> perm[i];
perm[i]--;
}
reverse(perm.begin(), perm.begin() + n);
long long cur = 0;
stack<long long> ans;
for (long long i = 0; i < n; i++) {
ans.push(cur);
long long a = perm[i];
sz[a] = 1;
sum[a] = arr[a];
if (a > 0 && sz[a - 1] > 0) {
union_sets(a - 1, a);
}
if (a < (n - 1) && sz[a + 1] > 0) {
union_sets(a, a + 1);
}
cur = max(cur, sum[find_set(a)]);
}
while (!ans.empty()) {
cout << ans.top() << "\n";
ans.pop();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int num[11];
int sa[11];
int sb[11];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d%d", &num[i], &sa[i], &sb[i]);
int can = -1;
for (int i = 0; i <= 9999; i++) {
int x = i;
int a = x / 1000, b = (x / 100) % 10, c = (x / 10) % 10, d = x % 10;
if (a == b || a == c || a == d || b == c || b == d || c == d) continue;
int ok = 0;
for (int j = 0; j < n; j++) {
x = num[j];
int a1 = x / 1000, b1 = (x / 100) % 10, c1 = (x / 10) % 10, d1 = x % 10;
int s1 = 0, s2 = 0;
if (a == a1) s1++;
if (b == b1) s1++;
if (c == c1) s1++;
if (d == d1) s1++;
if (a == b1) s2++;
if (a == c1) s2++;
if (a == d1) s2++;
if (b == a1) s2++;
if (b == c1) s2++;
if (b == d1) s2++;
if (c == a1) s2++;
if (c == b1) s2++;
if (c == d1) s2++;
if (d == a1) s2++;
if (d == c1) s2++;
if (d == b1) s2++;
if (sa[j] == 4 || (sa[j] == 3 && sb[j] == 1)) {
printf("Incorrect data\n");
return 0;
}
if (s1 == sa[j] && s2 == sb[j]) ok++;
}
if (ok == n && can != -1) {
printf("Need more data\n");
return 0;
} else if (ok == n)
can = i;
}
if (can == -1)
printf("Incorrect data\n");
else
printf("%.4d\n", can);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long fac[1010001], ifac[1010001];
long long pow1(long long x, long long y) {
long long ans = 1;
while (y > 0) {
if (y & 1LL) ans = ans * x;
ans %= 1000000007;
x = x * x;
x %= 1000000007;
y = y / 2;
}
return ans;
}
long long inv(long long x) { return pow1(x, 1000000007 - 2); }
void preprocess(void) {
fac[0] = 1;
for (auto i = (1); i < 1010001; i++) {
fac[i] = (i * fac[i - 1]) % 1000000007;
}
for (auto i = (0); i < 1010001; i++) {
ifac[i] = inv(fac[i]);
}
return;
}
long long C(long long x, long long y) {
long long ans = 1;
if (y > x) {
assert(false);
}
ans *= fac[x];
ans *= ifac[y];
ans %= 1000000007;
ans *= ifac[x - y];
ans %= 1000000007;
return ans;
}
long long C1(long long x, long long y) {
if (x == 0) {
if (y == 0)
return 1;
else
return 0;
}
if (y >= 0) {
long long kk = C(-x + y - 1, y);
if (y % 2) kk *= -1;
return kk;
} else if (y <= x) {
long long kk = C(-y - 1, x - y);
if ((x - y) % 2) kk *= -1;
return kk;
} else
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
preprocess();
int n, m, a, b;
cin >> n >> m >> a >> b;
long long ans = 0;
for (auto k = (1); k < min(n, m + 1); k++) {
long long kk = 1;
kk = kk * C1(-k, m - k) * ((m - k) % 2 == 0 ? 1 : -1);
;
kk %= 1000000007;
kk = kk * C(n - 2, k - 1);
kk %= 1000000007;
kk = kk * pow1(m, n - k - 1);
kk %= 1000000007;
kk = kk * fac[k - 1];
kk %= 1000000007;
kk *= ((k + 1) * pow1(n, n - k)) % 1000000007;
kk %= 1000000007;
kk *= inv(pow1(n, 2));
kk %= 1000000007;
kk %= 1000000007;
ans += kk;
ans %= 1000000007;
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef struct point {
double x, y;
point() { x = y = 0.0; }
point(double _x, double _y) {
x = _x;
y = _y;
}
void read() { scanf("%lf%lf", &x, &y); }
} Point;
Point P[200001];
double A[200001];
int n;
double cross(point p1, point p2, point p3) {
return (p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x);
}
double dot(point p1, point p2, point p3) {
return (p2.x - p1.x) * (p3.x - p1.x) + (p2.y - p1.y) * (p3.y - p1.y);
}
double area(point p1, point p2, point p3) {
return abs(p1.x * p2.y + p2.x * p3.y + p3.x * p1.y - p1.y * p2.x -
p2.y * p3.x - p3.y * p1.x) *
0.5;
}
double dist(point p1, point p2) {
return sqrt((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
}
double findArea(point p1, point p2, point p3) {
double t = dot(p2, p1, p3), d = dist(p1, p2), c = cross(p2, p1, p3);
return 0.5 * abs(t / d * c / d);
}
double qArea(int a, int b) {
if (a % (n + 1) > b % (n + 1))
return area(P[1], P[a], P[b]) + A[b - 1] - A[a - 1];
else
return A[b - 1] - A[a - 1] - area(P[1], P[a], P[b]);
}
int main() {
double ans = 1e17;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
P[i].read();
P[n + i] = P[i];
}
for (int rt = 0; rt < 2; rt++) {
for (int i = 1; i < 2 * n - 1; i++)
A[i] = area(P[1], P[i], P[i + 1]) + A[i - 1];
int id = 2;
for (int i = 1; i <= n; i++) {
if (id <= i) id = i + 1;
double t = dot(P[i + 1], P[i], P[id]);
while (dot(P[i + 1], P[i], P[id + 1]) - t < 1e-12)
t = dot(P[i + 1], P[i], P[++id]);
if (id == i + 1)
ans = 0.00;
else
ans = min(ans, findArea(P[i], P[i + 1], P[id]) - qArea(i + 1, id));
}
reverse(P + 1, P + n + n + 1);
}
printf("%.10lf\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 998244353;
const long long maxn = 1e6 + 7;
const double pi = acos(-1.0);
const double eps = 1e-10;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline void pr2(T x, int k = 64) {
long long i;
for (i = 0; i < k; i++) fprintf(stderr, "%d", (x >> i) & 1);
putchar(' ');
}
template <typename T>
inline void add_(T &A, int B, long long MOD = M) {
A += B;
(A >= MOD) && (A -= MOD);
}
template <typename T>
inline void mul_(T &A, long long B, long long MOD = M) {
A = (A * B) % MOD;
}
template <typename T>
inline void mod_(T &A, long long MOD = M) {
A %= MOD;
A += MOD;
A %= MOD;
}
template <typename T>
inline void max_(T &A, T B) {
(A < B) && (A = B);
}
template <typename T>
inline void min_(T &A, T B) {
(A > B) && (A = B);
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
inline long long powMM(long long a, long long b, long long mod = M) {
long long ret = 1;
for (; b; b >>= 1ll, a = a * a % mod)
if (b & 1) ret = ret * a % mod;
return ret;
}
int startTime;
void startTimer() { startTime = clock(); }
void printTimer() {
fprintf(stderr, "/--- Time: %ld milliseconds ---/\n", clock() - startTime);
}
int f[107][10][10][1 << 8][3];
char s[maxn];
vector<pair<int, int> > now;
int n;
int X, Y;
int query(int pos, int more_x, int more_y, int mask, int more) {
int i;
for (i = 0; i < (int)now.size(); i++)
if (((mask >> (i * 2)) & 3) == 3) {
mask = 3;
break;
}
if (pos == n) return !more_x && !more_y && more && mask == 3;
if (f[pos][more_x][more_y][mask][more] != -1)
return f[pos][more_x][more_y][mask][more];
int ret = 0, k;
for (k = 0; k < 10; k++) {
int nowx = X * k + more_x, nowy = Y * k + more_y;
int ax = nowx % 10, ay = nowy % 10, nxtmask = mask, nxtmore = more;
for (i = 0; i < (int)now.size(); i++) {
if (ax == now[i].first) nxtmask |= 1 << (i * 2);
if (ay == now[i].second) nxtmask |= 1 << (i * 2 + 1);
}
if (ay > s[pos] - '0') nxtmore = 0;
if (ay < s[pos] - '0') nxtmore = 2;
add_(ret, query(pos + 1, nowx / 10, nowy / 10, nxtmask, nxtmore));
}
return f[pos][more_x][more_y][mask][more] = ret;
}
int main() {
scanf("%s", s);
n = strlen(s);
reverse(s, s + n);
int i, j, k;
int ans = 0;
for (i = 1; i <= 9; i++)
for (j = i; j <= 9; j++)
if (gcd(i, j) == 1) {
X = i;
Y = j;
if (i == 1 && j == 1) {
int base = 1;
ans = 0;
for (k = 0; k < n; k++)
add_(ans, (long long)base * (s[k] - '0') % M), mul_(base, 10);
} else {
now.clear();
for (k = 1; k <= 10; k++)
if (k * i <= 9 && k * j <= 9)
now.push_back(make_pair(i * k, j * k));
int _l, _i, _j, _sta, _m;
for (_l = 0; _l < n; _l++)
for (_i = 0; _i < 10; _i++)
for (_j = 0; _j < 10; _j++)
for (_sta = 0; _sta < (1 << ((int)now.size() * 2)); _sta++)
for (_m = 0; _m < 3; _m++) {
f[_l][_i][_j][_sta][_m] = -1;
}
memset(f, 0xff, sizeof(f));
int base = query(0, 0, 0, 0, 1);
add_(ans, base);
if (i != j) add_(ans, base);
}
}
printf("%d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
c = min(a, min(b - 1, c - 2));
cout << 3 * c + 3;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
namespace combinatorics {
void add(long long& x, long long v) {
x += v;
x %= md;
}
void sub(long long& x, long long v) {
x -= v, x += md;
x %= md;
}
void mul(long long& x, long long v) {
x *= v;
x %= md;
}
long long be(long long b, long long e) {
long long res = 1;
while (e) {
if (e & 1) res *= b;
e >>= 1;
b *= b, b %= md;
res %= md;
}
return res;
}
vector<long long> fac, inv;
void factorial(long long n) {
fac.resize(n + 1);
inv.resize(n + 1);
fac[0] = 1;
for (long long i = 1; i <= n; i++) (fac[i] = fac[i - 1] * i) %= md;
for (long long i = 0; i <= n; i++) inv[i] = be(fac[i], md - 2);
return;
}
long long C(long long n, long long r) {
if (n >= fac.size()) {
cout << "Brick! you didnt calculate n!";
exit(1);
}
if (r > n) return 0;
long long res = fac[n];
res *= inv[r], res %= md;
res *= inv[n - r], res %= md;
return res;
}
long long P(long long n, long long r) {
if (n >= fac.size()) {
cout << "Brick! you didnt calculate n!";
exit(1);
}
if (r > n) return 0;
long long res = fac[n];
mul(res, inv[n - r]);
return res;
}
} // namespace combinatorics
using namespace combinatorics;
const long long MX = 3005;
long long p[MX][MX];
vector<pair<long long, long long>> inter(vector<pair<long long, long long>> a,
vector<pair<long long, long long>> b) {
long long mn = max(a[0].first, b[0].first), mx = min(a[1].first, b[1].first);
long long mnn = max(a[0].second, b[0].second),
mxx = min(a[2].second, b[2].second);
if (mn > mx || mnn > mxx) return {make_pair(-1, -1)};
return {make_pair(mn, mnn), make_pair(mx, mnn), make_pair(mn, mxx),
make_pair(mx, mxx)};
}
long long query(vector<pair<long long, long long>> a) {
if (a[0].first == -1) return 0;
return (p[a[3].first][a[3].second] - p[a[2].first - 1][a[2].second] -
p[a[1].first][a[1].second - 1] + p[a[0].first - 1][a[0].second - 1]);
}
signed main() {
factorial(MX * 10);
for (long long i = 0; i < MX; i++)
for (long long j = 0; j < MX; j++) p[i][j] = 0;
long long n, m, r;
cin >> n >> m >> r;
vector<array<long long, 3>> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1] >> a[i][2];
a[i][0] += 1000;
a[i][1] += 1000;
p[a[i][0]][a[i][1]] = 1;
}
for (long long i = 0; i < MX; i++) {
for (long long j = 1; j < MX; j++) {
p[i][j] += p[i][j - 1];
}
}
for (long long j = 0; j < MX; j++)
for (long long i = 1; i < MX; i++) p[i][j] += p[i - 1][j];
long long ans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
long long val = 2 * a[i][2] * a[j][2];
val %= md;
vector<pair<long long, long long>> sq1 = {
make_pair(a[i][0] - r, a[i][1] - r),
make_pair(a[i][0] + r, a[i][1] - r),
make_pair(a[i][0] - r, a[i][1] + r),
make_pair(a[i][0] + r, a[i][1] + r)};
vector<pair<long long, long long>> sq2 = {
make_pair(a[j][0] - r, a[j][1] - r),
make_pair(a[j][0] + r, a[j][1] - r),
make_pair(a[j][0] - r, a[j][1] + r),
make_pair(a[j][0] + r, a[j][1] + r)};
long long qsq = query(sq1), qsq1 = query(sq2),
qintr = query(inter(sq1, sq2));
long long exc = n - qsq - qsq1 + qintr, inc = qsq - qintr,
inc1 = qsq1 - qintr, both = qintr;
val *=
(C(n, m) - C(inc + exc, m) - C(inc1 + exc, m) + C(exc, m) + 2 * md) %
md,
val %= md;
ans += val, ans %= md;
}
}
for (long long i = 0; i < n; i++) {
long long inc = 0, exc = 0, val = a[i][2] * a[i][2];
val %= md;
for (long long j = 0; j < n; j++) {
if (max(abs(a[i][0] - a[j][0]), abs(a[i][1] - a[j][1])) <= r)
++inc;
else
++exc;
}
val *= ((C(n, m) - C(exc, m) + md) % md), val %= md;
ans += val, ans %= md;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, next;
} f[200010 << 1];
int n, k, d[200010], head[200010], l = 0;
void Dfs(int u, int fa) {
d[u] = d[fa] + 1;
for (int i = head[u]; i; i = f[i].next)
if (f[i].to != fa) Dfs(f[i].to, u);
}
int main() {
cin >> n >> k;
for (int i = 2; i <= n; i++) {
int v = (i <= k + 1) ? 1 : i - k;
({
f[++l] = (Edge){v, head[i]};
head[i] = l;
});
({
f[++l] = (Edge){i, head[v]};
head[v] = l;
});
}
Dfs(n, 0);
int ans = 0;
for (int i = 1; i <= n; i++) ans = max(ans, d[i]);
cout << ans - 1 << endl;
for (int i = 2; i <= n; i++) {
int v = (i <= k + 1) ? 1 : i - k;
printf("%d %d\n", i, v);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5;
int num[maxn];
int dp[20];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int ans = 0;
for (int j = 0; j < k; j++) {
scanf("%d", &num[j]);
ans = ans * 2 + num[j];
}
dp[ans] = 1;
}
for (int i = 0; i < 16; i++)
for (int j = 0; j < 16; j++) {
if (dp[i] && dp[j] && !(i & j)) {
printf("YES");
return 0;
}
}
printf("NO");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 2e5 + 10;
vector<pair<int, int> > res;
vector<int> res2, e[SIZE];
int N, L, R;
int bfs[SIZE], sons[SIZE];
int used[SIZE], tt, tt2, father[SIZE];
int CC, PTR;
void dfs(int x, int lt, int o) {
for (int i = 0; i < (((int)(e[x]).size())); ++i) {
int y = e[x][i];
if (y == lt) continue;
dfs(y, x, o);
}
if (lt != o && x != o) {
if (PTR != x) {
res.push_back(make_pair(CC, PTR));
res2.push_back(x);
PTR = x;
}
res.push_back(make_pair(x, lt));
res2.push_back(o);
}
}
void go(int x, int lt) {
CC = x;
for (int i = 0; i < (((int)(e[x]).size())); ++i) {
int y = e[x][i];
if (y == lt) continue;
PTR = y;
dfs(y, x, y);
if (PTR != y) {
res.push_back(make_pair(CC, PTR));
res2.push_back(y);
}
}
}
void build(int st) {
bfs[0] = st;
tt2--;
used[st] = tt2;
int i = 0, j = 1;
for (; i < j; i++) {
int x = bfs[i];
sons[x] = 1;
for (int k = 0; k < (((int)(e[x]).size())); ++k) {
int y = e[x][k];
if (used[y] == tt || used[y] == tt2) continue;
father[y] = x;
used[y] = tt2;
bfs[j++] = y;
}
}
int num = j;
for (i = j - 1; i >= 0; i--) {
int x = bfs[i];
if (sons[x] * 2 >= num) {
if (sons[x] * 2 > num) {
;
go(x, x);
return;
} else {
int z = father[x];
go(x, z);
go(z, x);
return;
}
}
sons[father[x]] += sons[x];
}
}
void init() {
tt++;
build(1);
}
int main() {
scanf("%d", &(N));
for (int i = (1); i < (N); ++i) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
init();
printf("%d\n", ((int)(res).size()));
for (int i = 0; i < (((int)(res).size())); ++i)
printf("%d %d %d\n", res[i].first, res[i].second, res2[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int m = 1e9 + 7;
int bin_pow(int x, int k) {
if (k == 0) return 1;
int g = bin_pow(x, k / 2);
g = (1ll * g * g) % m;
if (k % 2 > 0) g = (1ll * g * x) % m;
return g;
}
signed main() {
iostream::sync_with_stdio(0);
cin.tie(0);
setlocale(LC_ALL, "Russian");
int tt, n, p, i, j, r, second, ans, add;
vector<int> read, k, cnt, st;
cin >> tt;
for (; tt > 0; tt--) {
cin >> n >> p;
read.assign(n, 0);
k.clear();
cnt.clear();
st.clear();
for (i = 0; i < n; i++) cin >> read[i];
if (p == 1) {
if (n % 2 > 0)
cout << "1\n";
else
cout << "0\n";
continue;
}
sort(read.begin(), read.end());
for (i = 0; i < n; i++) {
j = i + 1;
while (j < n && read[i] == read[j]) j++;
k.push_back(read[i]);
cnt.push_back(j - i);
i = j - 1;
}
st.push_back(bin_pow(p, k[0]));
for (i = 1; i < k.size(); i++)
st.push_back((1ll * st[i - 1] * bin_pow(p, k[i] - k[i - 1])) % m);
ans = 0;
for (i = k.size() - 1; i >= 0; i--) {
if (cnt[i] % 2 == 0) continue;
j = i - 1;
second = 1;
while (j >= 0) {
for (r = 0; r < k[j + 1] - k[j] && second <= n; r++) second *= p;
if (r < k[j + 1] - k[j] || second > n) break;
add = min(second, cnt[j]);
second -= add;
ans = (ans - 1ll * cnt[j] * st[j] + 2ll * m * m) % m;
cnt[j] -= add;
if (second == 0) break;
j--;
}
if (second > 0) {
while (j >= 0) {
ans = (ans - 1ll * cnt[j] * st[j] + 2ll * m * m) % m;
j--;
}
ans = (ans + st[i]) % m;
break;
}
ans = 0;
i = j + 1;
}
cout << ans << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, l, n, test_case;
test_case = 1;
while (test_case--) {
cin >> n >> k;
for (i = 1; i <= n; i++) {
vector<int> vec;
j = i;
while (j <= n) {
vec.push_back(j);
j += (2 * k + 1);
}
j -= (2 * k + 1);
if (j + k >= n) {
cout << vec.size() << "\n";
for (auto it : vec) cout << it << " ";
return 0;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = -1;
const int INF = 1.01e9;
int main() {
vector<string> name = {"Anka", "Chapay", "Cleo", "Troll",
"Dracul", "Snowy", "Hexadecimal"};
int n;
cin >> n;
set<pair<string, string>> q;
for (int i = 0; i < n; i++) {
string s, t;
string tmp;
cin >> s >> tmp >> t;
assert(tmp == "likes");
q.insert({s, t});
}
vector<int> hp(3);
for (int i = 0; i < 3; i++) {
cin >> hp[i];
}
pair<int, int> best = {INF * 2, 0};
int m = 7;
int all = 1;
for (int i = 0; i < m; i++) {
all *= 3;
}
for (int mask = 0; mask < all; mask++) {
vector<int> team(m);
int x = mask;
vector<int> cnt(3);
for (int i = 0; i < m; i++, x /= 3) {
team[i] = x % 3;
cnt[team[i]]++;
}
int mn = INF;
int mx = 0;
int fr = 0;
bool ok = 1;
for (int i = 0; i < 3; i++) {
if (cnt[i] == 0) {
ok = 0;
break;
}
mn = min(mn, hp[i] / cnt[i]);
mx = max(mx, hp[i] / cnt[i]);
}
if (ok == 0) continue;
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
if (team[i] == team[j]) {
fr += q.count({name[i], name[j]});
}
}
}
int score = mx - mn;
if (score < best.first || (best.first == score && best.second < fr)) {
best = {score, fr};
}
}
cout << best.first << " " << best.second << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int min = 100;
void fill_arr(int m, int n, int* arr) {
int num;
while (m--) {
cin >> num;
for (int i = num - 1; i < n && arr[i] == 0; i++) {
arr[i] = num;
}
}
}
void print(int* arr, int n) {
int st = 0;
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
}
int main() {
int n, m;
cin >> n >> m;
int arr[101] = {0};
fill_arr(m, n, arr);
print(arr, n);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int flag1 = 0, flag2 = 0;
long long x1, y1, x2, y2;
long long x3, y3, x4, y4;
long long x5, y5, x6, y6;
long long bx1, by1, bx2, by2, bArea1;
long long bx3, by3, bx4, by4, bArea2;
long long total, bArea3;
cin >> x1 >> y1 >> x2 >> y2;
cin >> x3 >> y3 >> x4 >> y4;
cin >> x5 >> y5 >> x6 >> y6;
total = (x2 - x1) * (y2 - y1);
long long xlength = min(x2, x4) - max(x1, x3),
ylength = min(y2, y4) - max(y1, y3);
if (xlength > 0 && ylength > 0) {
flag1 = 1;
bx1 = max(x1, x3), by1 = max(y1, y3);
bx2 = min(x2, x4), by2 = min(y2, y4);
bArea1 = xlength * ylength;
total = total - bArea1;
}
xlength = min(x2, x6) - max(x1, x5), ylength = min(y2, y6) - max(y1, y5);
if (xlength > 0 && ylength > 0) {
flag2 = 1;
bx3 = max(x1, x5), by3 = max(y1, y5);
bx4 = min(x2, x6), by4 = min(y2, y6);
bArea2 = xlength * ylength;
total = total - bArea2;
}
if (flag1 == 1 && flag2 == 1) {
xlength = min(bx2, bx4) - max(bx1, bx3),
ylength = min(by2, by4) - max(by1, by3);
if (xlength > 0 && ylength > 0) {
flag2 = 1;
bArea3 = xlength * ylength;
total = total + bArea3;
}
}
if (total > 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int maxn = 1e5 + 3;
void mf() { freopen("input.in", "r", stdin); }
int check(int l, int r) {
cout << 1 << " " << (r - l + 1) << " " << 1;
for (int i = l; i <= r; i++) cout << " " << i;
cout << endl;
fflush(stdout);
int curr;
cin >> curr;
return curr;
}
int n;
void solve() {
cin >> n;
int mm = check(2, n);
int l = 2, r = n;
while (l < r) {
int mid = (l + r) / 2;
if (check(l, mid) == mm) {
r = mid;
} else {
l = mid + 1;
}
}
cout << 1 << " " << (n - 1) << " " << l;
for (int i = 1; i <= n; i++) {
if (i != l) cout << " " << i;
}
cout << endl;
fflush(stdout);
int ans;
cin >> ans;
cout << -1 << " " << ans << endl;
fflush(stdout);
}
int main() {
ios_base::sync_with_stdio(false);
int ntest;
cin >> ntest;
while (ntest--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
int l = 1;
int r = n;
while (a[l] > a[l - 1]) l++;
while (a[r] < a[r - 1]) r--;
int tmp = a[l - 1];
int flag = 1;
for (int i = l - 1; i <= r; i++) {
if (a[i] != tmp) flag = 0;
}
if (flag)
printf("YES");
else
printf("NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, mp[110][110], cnt;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (mp[i][j] == 0)
for (int c = 1; c <= 26; c++)
if (mp[i - 1][j] != c && mp[i][j + 1] != c)
if (mp[i][j - 1] != c) {
cnt = 1;
mp[i][j] = c;
break;
} else if (i + cnt > n)
continue;
else {
if (cnt == 0 && mp[i][j - 1] == c) continue;
++cnt;
for (int k = 1; k <= cnt; k++)
mp[i + k - 1][j] = mp[i + cnt - 1][j - k + 1] = c;
break;
}
else
continue;
else
cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c", 'A' + mp[i][j] - 1);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s1, s2;
cin >> s1;
cin >> s2;
if (((s1[0] == '<') && (s2[0] == '^')) ||
((s1[0] == '>') && (s2[m - 1] == '^')) ||
((s1[n - 1] == '<') && (s2[0] == 'v')) ||
((s1[n - 1] == '>') && (s2[m - 1] == 'v')))
cout << "NO";
else
cout << "YES";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
long long a[maxn];
int x;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 30; i >= 0; i--) {
int num = 0;
for (int j = 1; j <= n; j++) {
if (((long long int)1 << i) & a[j]) {
num++;
x = j;
}
}
if (num == 1) break;
}
if (x != 0) cout << a[x] << " ";
for (int i = 1; i <= n; i++) {
if (x != i) cout << a[i] << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100];
int g1, mn, id;
void mini(int l, int r) {
mn = a[l];
id = l;
for (g1 = l; g1 < r; g1++) {
if (mn > a[g1]) {
mn = a[g1];
id = g1;
}
}
}
int main() {
int q, n, i, j, cnt;
cin >> q;
while (q) {
q--;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
cnt = n - 1;
for (i = 0; i < n && cnt; i++) {
mini(i, n);
j = id;
if (j == i) continue;
while (id - i && cnt) {
cnt--;
swap(a[id], a[id - 1]);
id--;
}
i = j - 1;
}
for (i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9 + 7;
struct AhoCorasick {
enum { alpha = 26, first = 'a' };
struct Node {
int back, next[alpha], start = -1, end = -1, nmatches = 0;
Node(int v) { memset(next, v, sizeof(next)); }
};
vector<Node> N;
vector<int> backp;
void insert(string& s, int j) {
assert(!s.empty());
int n = 0;
for (char c : s) {
int& m = N[n].next[c - first];
if (m == -1) {
n = m = (int)(N).size();
N.emplace_back(-1);
} else
n = m;
}
if (N[n].end == -1) N[n].start = j;
backp.push_back(N[n].end);
N[n].end = j;
N[n].nmatches++;
}
AhoCorasick(vector<string>& pat) : N(1, -1) {
for (int i = 0; i < ((int)(pat).size()); ++i) insert(pat[i], i);
N[0].back = (int)(N).size();
N.emplace_back(0);
queue<int> q;
for (q.push(0); !q.empty(); q.pop()) {
int n = q.front(), prev = N[n].back;
for (int i = 0; i < (alpha); ++i) {
int &ed = N[n].next[i], y = N[prev].next[i];
if (ed == -1)
ed = y;
else {
N[ed].back = y;
(N[ed].end == -1 ? N[ed].end : backp[N[ed].start]) = N[y].end;
N[ed].nmatches += N[y].nmatches;
q.push(ed);
}
}
}
}
vector<int> find(string word) {
int n = 0;
vector<int> res;
for (char c : word) {
n = N[n].next[c - first];
res.push_back(N[n].end);
}
return res;
}
vector<vector<int> > findAll(vector<string>& pat, string word) {
vector<int> r = find(word);
vector<vector<int> > res((int)(word).size());
for (int i = 0; i < ((int)(word).size()); ++i) {
int ind = r[i];
while (ind != -1) {
res[i - (int)(pat[ind]).size() + 1].push_back(ind);
ind = backp[ind];
}
}
return res;
}
};
int main() {
string text;
cin >> text;
int n;
cin >> n;
vector<string> pattern(n);
vector<int> k(n);
for (int i = 0; i < n; ++i) {
cin >> k[i] >> pattern[i];
}
AhoCorasick aut(pattern);
vector<vector<int> > occ = aut.findAll(pattern, text);
vector<vector<int> > pos(n, vector<int>());
for (int i = 0; i < text.size(); ++i) {
for (int x : occ[i]) pos[x].push_back(i);
}
for (int i = 0; i < n; ++i) {
if (pos[i].size() < k[i]) {
puts("-1");
} else {
int ans = oo;
for (int j = 0; j <= pos[i].size() - k[i]; ++j) {
int len = pos[i][j + k[i] - 1] - pos[i][j] + pattern[i].size();
ans = min(ans, len);
}
printf("%d\n", ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long fpow(int a, int b) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = x * y;
if (x > 1000000007) x %= 1000000007;
}
y = y * y;
if (y > 1000000007) y %= 1000000007;
b /= 2;
}
return x;
}
int main() {
int n;
cin >> n;
string A, B;
cin >> A >> B;
bool ALess = 0, BLess = 0;
int questions = 0;
for (int i = 0; i < A.size(); i++) {
if (A[i] != '?' && B[i] != '?') {
if (A[i] < B[i])
ALess = 1;
else if (B[i] < A[i])
BLess = 1;
else
;
} else if (A[i] == '?' && B[i] == '?')
questions += 2;
else
questions++;
}
if (questions == 0) {
if (ALess && BLess)
printf("1\n");
else
printf("0\n");
} else {
if (ALess && BLess) {
long long ans = fpow(10, questions);
cout << ans << "\n";
} else if (ALess) {
long long ans = 1;
for (int i = 0; i < A.size(); i++) {
if (A[i] == '?' && B[i] == '?')
ans = (ans * 55LL) % 1000000007;
else if (A[i] == '?')
ans = (ans * (long long)(1 + B[i] - '0')) % 1000000007;
else if (B[i] == '?')
ans = (ans * (long long)(10 - (A[i] - '0'))) % 1000000007;
else
;
}
ans = (fpow(10, questions) + 1000000007 - ans) % 1000000007;
cout << ans << "\n";
} else if (BLess) {
long long ans = 1;
for (int i = 0; i < A.size(); i++) {
if (A[i] == '?' && B[i] == '?')
ans = (ans * 55LL) % 1000000007;
else if (A[i] == '?')
ans = (ans * (long long)(10 - (B[i] - '0'))) % 1000000007;
else if (B[i] == '?')
ans = (ans * (long long)(1 + A[i] - '0')) % 1000000007;
else
;
}
ans = (fpow(10, questions) + 1000000007 - ans) % 1000000007;
cout << ans << "\n";
} else {
long long ans1 = 1;
for (int i = 0; i < A.size(); i++) {
if (A[i] == '?' && B[i] == '?')
ans1 = (ans1 * 55LL) % 1000000007;
else if (A[i] == '?')
ans1 = (ans1 * (long long)(10 - (B[i] - '0'))) % 1000000007;
else if (B[i] == '?')
ans1 = (ans1 * (long long)(1 + A[i] - '0')) % 1000000007;
else
;
}
long long ans2 = 1;
for (int i = 0; i < A.size(); i++) {
if (A[i] == '?' && B[i] == '?')
ans2 = (ans2 * 55LL) % 1000000007;
else if (A[i] == '?')
ans2 = (ans2 * (long long)(1 + B[i] - '0')) % 1000000007;
else if (B[i] == '?')
ans2 = (ans2 * (long long)(10 - (A[i] - '0'))) % 1000000007;
else
;
}
long long ans3 = 1;
int cnt = 0;
for (int i = 0; i < A.size(); i++) {
if (A[i] == '?' && B[i] == '?') cnt++;
}
ans3 = fpow(10, cnt);
long long ans = (ans1 + ans2 + 1000000007 - ans3) % 1000000007;
ans = (fpow(10, questions) + 1000000007 - ans) % 1000000007;
cout << ans << "\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using std::max;
using std::min;
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
std::mt19937 rnd(std::chrono::steady_clock::now().time_since_epoch().count());
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
inline _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
inline void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
inline void chmin(_Tp &a, const _Tp &b) {
(b < a) && (a = b);
}
template <typename _Tp>
inline void read(_Tp &x) {
char ch(getchar());
bool f(false);
while (!isdigit(ch)) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (isdigit(ch)) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
f && (x = -x);
}
template <typename _Tp, typename... Args>
inline void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
inline int read_str(char *s) {
char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 1000005;
long long dp[N], _[N];
int main() {
int k;
read(k), k = 3 * (k - 1);
int mul = 1;
memset(dp, -63, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < 6; ++i) {
int tmp = k, t = 1, x;
read(x);
memset(_, -63, sizeof(_));
for (int v = 0; v < 10; ++v) {
long long cost = 1ll * mul * v, w = v % 3 == 0 ? 1ll * (v / 3) * x : 0;
for (int i = 0; i + cost < N; ++i) chmax(_[i + cost], dp[i] + w);
}
memcpy(dp, _, sizeof(dp));
while (tmp > t) {
tmp -= t;
long long cost = 1ll * mul * 3 * t, w = 1ll * x * t;
if (cost < N)
for (int i = N - cost - 1; i >= 0; --i) chmax(dp[i + cost], dp[i] + w);
t <<= 1;
}
long long cost = 1ll * mul * 3 * tmp, w = 1ll * x * tmp;
if (cost < N)
for (int i = N - cost - 1; i >= 0; --i) chmax(dp[i + cost], dp[i] + w);
mul = mul * 10;
}
int q, x;
read(q);
while (q--) {
read(x);
printf("%lld\n", dp[x]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[1100], b[1100];
int can(int x) {
int need = 0;
for (int i = 1; i <= n; i++) need += max(0, a[i] * x - b[i]);
if (need > k)
return 0;
else
return 1;
}
int erfen(int l, int r) {
if (l == r)
return l;
else if (l == r - 1) {
if (can(r))
return r;
else
return l;
} else {
int mid = (l + r) / 2;
if (can(mid))
return erfen(mid, r);
else
return erfen(l, mid - 1);
}
}
int main() {
int ans, i;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) cin >> b[i];
ans = erfen(0, 2000);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
template <class T>
typename T::value_type arr_sum(const T& v, int n) {
typename T::value_type sum = 0;
for (int i = 0; i < n; ++i) sum += v[i];
return sum;
}
template <class T>
long long arr_count(const T& v, int n, int t) {
long long count = 0;
for (int i = 0; i < n; ++i) count += (v[i] == t);
return count;
}
template <class T>
typename T::value_type arr_maxi(const T& v, int n) {
typename T::value_type maxi = 0;
for (int i = 1; i < n; ++i)
if (v[maxi] < v[i]) maxi = i;
return maxi;
}
template <class T>
typename T::value_type arr_mini(const T& v, int n) {
typename T::value_type mini = 0;
for (int i = 1; i < n; ++i)
if (v[mini] > v[i]) mini = i;
return mini;
}
template <class T>
typename T::value_type arr_max(const T& v, int n) {
typename T::value_type max = v[0];
for (int i = 1; i < n; ++i)
if (max < v[i]) max = v[i];
return max;
}
template <class T>
typename T::value_type arr_min(const T& v, int n) {
typename T::value_type min = v[0];
for (int i = 1; i < n; ++i)
if (min > v[i]) min = v[i];
return min;
}
using namespace std;
string a[2000];
int b[2000][2000];
int n, m;
int max1 = 0, max2 = 0;
int c1 = 0, c2 = 0;
int t = 1;
int c = 0;
void __fastcall dfs(int i, int j) {
if (t >= max2) {
swap(max2, max1);
swap(c2, c1);
max2 = t;
c2 = c;
if (c1 == c2) {
c1 = c2;
max1 = max2;
}
}
b[i][j] = c;
if (a[i][j + 1] == '<') {
if (b[i][j + 1] == c) {
cout << -1;
exit(0);
} else if (b[i][j + 1] == 0) {
++t;
dfs(i, j + 1);
--t;
}
}
if (a[i][j - 1] == '>') {
if (b[i][j - 1] == c) {
cout << -1;
exit(0);
} else if (b[i][j - 1] == 0) {
++t;
dfs(i, j - 1);
--t;
}
}
if (a[i + 1][j] == '^') {
if (b[i + 1][j] == c) {
cout << -1;
exit(0);
} else if (b[i + 1][j] == 0) {
++t;
dfs(i + 1, j);
--t;
}
}
if (a[i - 1][j] == 'v') {
if (b[i - 1][j] == c) {
cout << -1;
exit(0);
} else if (b[i - 1][j] == 0) {
++t;
dfs(i - 1, j);
--t;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] = a[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
b[i][j] = 0;
}
}
for (int i = 1; i < n - 1; ++i) {
for (int j = 1; j < m - 1; ++j) {
if (a[i][j] == '^' && (a[i - 1][j] == '#' || a[i - 1][j] == 'v')) {
++c;
dfs(i, j);
continue;
}
if (a[i][j] == '>' && (a[i][j + 1] == '#' || a[i][j + 1] == '<')) {
++c;
dfs(i, j);
continue;
}
if (a[i][j] == '<' && (a[i][j - 1] == '#' || a[i][j - 1] == '>')) {
++c;
dfs(i, j);
continue;
}
if (a[i][j] == 'v' && (a[i + 1][j] == '#' || a[i + 1][j] == '^')) {
++c;
dfs(i, j);
continue;
}
}
}
if (c1 == c2 && c1 != 0) {
cout << max1 + max2 - 1 << endl;
} else {
cout << max1 + max2 << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int cube[30];
bool same(int a, int b, int c, int d) {
return cube[a] == cube[b] && cube[b] == cube[c] && cube[c] == cube[d];
}
int main() {
bool ans = 0;
for (int i = 1; i <= 24; i++) scanf("%d", cube + i);
if (same(1, 2, 3, 4) && same(9, 10, 11, 12)) {
if (same(5, 6, 15, 16) && same(17, 18, 7, 8) && same(21, 22, 19, 20) &&
same(13, 14, 23, 24))
ans = 1;
if (same(13, 14, 7, 8) && same(5, 6, 19, 20) && same(17, 18, 23, 24) &&
same(21, 22, 15, 16))
ans = 1;
}
if (same(13, 14, 15, 16) && same(17, 18, 19, 20)) {
if (same(1, 3, 6, 8) && same(5, 7, 10, 12) && same(9, 11, 21, 23) &&
same(2, 4, 22, 24))
ans = 1;
if (same(5, 7, 2, 4) && same(9, 11, 6, 8) && same(10, 12, 22, 24) &&
same(1, 3, 21, 23))
ans = 1;
}
if (same(5, 6, 7, 8) && same(21, 22, 23, 24)) {
if (same(1, 2, 14, 16) && same(13, 15, 9, 10) && same(11, 12, 17, 19) &&
same(18, 20, 3, 4))
ans = 1;
if (same(1, 2, 17, 19) && same(13, 15, 3, 4) && same(11, 12, 14, 16) &&
same(18, 20, 9, 10))
ans = 1;
}
printf("%s\n", ans ? "YES" : "NO");
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.