solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int num[] = {0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1,
14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1,
51, 1, 2, 1, 14, 1, 2, 2, 14, 1, 6, 1, 4, 2, 2, 1,
52, 2, 5, 1, 5, 1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4,
267, 1, 4, 1, 5, 1, 4, 1, 50, 1, 2, 3, 4, 1, 6, 1,
52, 15, 2, 1, 15, 1, 2, 1, 12, 1, 10, 1, 4, 2};
int main() {
int n;
cin >> n;
cout << num[n] << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
template <class T>
inline void chkmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void chkmax(T &a, T b) {
if (a < b) a = b;
}
const int MOD = 1e9 + 7;
const int MAXN = 1 << 18;
int a[MAXN];
long long w[MAXN + MAXN];
int wa[MAXN + MAXN];
void add(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int sum(int a, int b) { return a + b >= MOD ? a + b - MOD : a + b; }
int mul(long long a, long long b) { return (a * b) % (long long)MOD; }
void Init() {
for (int i = MAXN - 1; i; --i) {
wa[i] = sum(wa[2 * i], wa[2 * i + 1]);
w[i] = w[2 * i] + w[2 * i + 1];
}
}
void ChWA(int v, int d) {
wa[v] = d;
for (v /= 2; v; v /= 2) wa[v] = sum(wa[2 * v], wa[2 * v + 1]);
}
int GetWA(int v, int l, int r, int L, int R) {
if (r <= L || R <= l) return 0;
if (L <= l && r <= R) return wa[v];
int m = (l + r) / 2;
return sum(GetWA(2 * v, l, m, L, R), GetWA(2 * v + 1, m, r, L, R));
}
void ChW(int v, long long d) {
w[v] = d;
for (v /= 2; v; v /= 2) w[v] = w[2 * v] + w[2 * v + 1];
}
long long GetW(int v, int l, int r, int L, int R) {
if (r <= L || R <= l) return 0;
if (L <= l && r <= R) return w[v];
int m = (l + r) / 2;
return GetW(2 * v, l, m, L, R) + GetW(2 * v + 1, m, r, L, R);
}
int CalcRes(int i, int L, int R) {
int res = mul(a[i], GetW(1, 0, MAXN, L, i) % (long long)MOD);
add(res, -GetWA(1, 0, MAXN, L, i) + MOD);
add(res, GetWA(1, 0, MAXN, i + 1, R));
add(res, -mul(a[i], GetW(1, 0, MAXN, i + 1, R) % (long long)MOD) + MOD);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] -= i;
}
for (int i = 0; i < n; ++i) {
cin >> w[MAXN + i];
wa[MAXN + i] = mul(a[i], w[MAXN + i]);
}
Init();
for (int qq = 0; qq < q; ++qq) {
int L;
cin >> L;
if (L > 0) {
--L;
int R;
cin >> R;
int l = L, r = R;
while (r - l > 1) {
int m = (l + r) / 2;
if (GetW(1, 0, MAXN, L, m + 1) <= GetW(1, 0, MAXN, m + 1, R))
l = m;
else
r = m;
}
if (GetW(1, 0, MAXN, L, r) < GetW(1, 0, MAXN, r, R))
cout << CalcRes(r, L, R) << '\n';
else
cout << CalcRes(l, L, R) << '\n';
} else {
L = -L;
--L;
int nw;
cin >> nw;
ChW(MAXN + L, nw);
ChWA(MAXN + L, mul(nw, a[L]));
}
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10;
const int MOD = 51123987;
char str[MAXN];
char s[MAXN];
int dp[200][53][53][53];
int nex[200][3];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
memset(dp, 0, sizeof(dp));
scanf("%s", str);
int k = 0;
s[k++] = str[0];
for (int i = 1; i < n; i++) {
if (str[i] != str[i - 1]) s[k++] = str[i];
}
memset(nex, -1, sizeof(nex));
for (int i = 0; i < k; i++) {
for (int j = i; j < k; j++) {
if (s[j] == 'a' && nex[i][0] == -1) nex[i][0] = j;
if (s[j] == 'b' && nex[i][1] == -1) nex[i][1] = j;
if (s[j] == 'c' && nex[i][2] == -1) nex[i][2] = j;
}
}
int tn = n / 3 + 1;
dp[0][0][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int A = 0; A <= tn; A++) {
for (int B = 0; B <= tn; B++) {
for (int C = 0; C <= tn; C++) {
if (dp[i - 1][A][B][C] == 0) continue;
int dex = nex[i - 1][0];
if (dex != -1) {
dp[dex][A + 1][B][C] += dp[i - 1][A][B][C];
dp[dex][A + 1][B][C] %= MOD;
}
dex = nex[i - 1][1];
if (dex != -1) {
dp[dex][A][B + 1][C] += dp[i - 1][A][B][C];
dp[dex][A][B + 1][C] %= MOD;
}
dex = nex[i - 1][2];
if (dex != -1) {
dp[dex][A][B][C + 1] += dp[i - 1][A][B][C];
dp[dex][A][B][C + 1] %= MOD;
}
}
}
}
}
int res = 0;
if (n % 3 == 0) {
for (int i = 0; i < k; i++) {
res += dp[i][n / 3][n / 3][n / 3];
res %= MOD;
}
} else if (n % 3 == 1) {
for (int i = 0; i < k; i++) {
res += dp[i][n / 3 + 1][n / 3][n / 3];
res %= MOD;
res += dp[i][n / 3][n / 3 + 1][n / 3];
res %= MOD;
res += dp[i][n / 3][n / 3][n / 3 + 1];
res %= MOD;
}
} else {
for (int i = 0; i < k; i++) {
res += dp[i][n / 3 + 1][n / 3 + 1][n / 3];
res %= MOD;
res += dp[i][n / 3 + 1][n / 3][n / 3 + 1];
res %= MOD;
res += dp[i][n / 3][n / 3 + 1][n / 3 + 1];
res %= MOD;
}
}
printf("%d\n", res);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
struct Team {
int score, goals, miss, matches;
};
int get(int x1, int x2) {
if (x1 > x2) return 3;
if (x1 == x2) return 1;
return 0;
}
struct Cmp {
bool operator()(const pair<string, Team> &p1, const pair<string, Team> &p2) {
if (p1.second.score != p2.second.score)
return p1.second.score > p2.second.score;
int d1 = p1.second.goals - p1.second.miss,
d2 = p2.second.goals - p2.second.miss;
if (d1 != d2) return d1 > d2;
if (p1.second.goals != p2.second.goals)
return p1.second.goals > p2.second.goals;
return p1.first < p2.first;
}
};
int main() {
int n, m, k, x[100005], y[100005];
char t1[22], t2[22];
int x1, x2;
map<string, Team> team;
for (typeof(0) i = (0); i < (5); ++i) {
scanf("%s%s%d:%d", t1, t2, &x1, &x2);
string s1 = string(t1), s2 = string(t2);
team[s1].goals += x1;
team[s1].miss += x2;
team[s1].score += get(x1, x2);
team[s1].matches++;
team[s2].goals += x2;
team[s2].miss += x1;
team[s2].score += get(x2, x1);
team[s2].matches++;
}
vector<pair<string, Team> > team2;
for (typeof((team).begin()) it = (team).begin(); it != (team).end(); ++it) {
Team cur = {it->second.score, it->second.goals, it->second.miss,
it->second.matches};
team2.push_back(make_pair(it->first, cur));
}
sort((team2).begin(), (team2).end(), Cmp());
int i, opponent;
for (i = 0; i < 4; ++i)
if (team2[i].first == "BERLAND") break;
for (int j = 0; j < 4; ++j)
if (j != i && team2[j].second.matches == 2) {
opponent = j;
break;
}
if (i < 2) {
puts("1:0");
} else if (team2[i].second.score + 3 < team2[1].second.score) {
puts("IMPOSSIBLE");
} else if (team2[i].second.score + 3 > team2[1].second.score) {
puts("1:0");
} else if (team2[i].second.score + 3 == team2[1].second.score) {
team2[i].second.score += 3;
int res, res2, ans, ans2;
int mi = 10000;
for (res = 1; res < 50; ++res) {
bool cont = true;
for (res2 = 0; res2 < res; ++res2) {
team2[opponent].second.miss += res;
team2[opponent].second.goals += res2;
team2[i].second.goals += res;
team2[i].second.miss += res2;
sort((team2).begin(), (team2).end(), Cmp());
if (team2[0].first != "BERLAND" && team2[1].first != "BERLAND")
cont = false;
if (cont && res - res2 < mi) {
ans = res;
ans2 = res2;
mi = res - res2;
}
for (typeof(0) x = (0); x < (4); ++x)
if (team2[x].second.matches == 2) {
if (team2[x].first == "BERLAND") {
team2[x].second.goals -= res;
team2[x].second.miss -= res2;
i = x;
} else {
team2[x].second.goals -= res2;
team2[x].second.miss -= res;
opponent = x;
}
}
if (!cont) break;
}
}
printf("%d:%d\n", ans, ans2);
return 0;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long inf = 0x7f7f7f7f7f7f7f7f;
int T;
int n;
int b[200010];
map<int, int> mp;
int main() {
scanf("%d", &T);
while (T--) {
mp.clear();
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), mp[b[i]]++;
bool flag = false;
for (int i = 1; i <= n; i++)
if (mp[b[i]] > 1) {
puts("YES");
flag = true;
break;
}
if (!flag) puts("NO");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 200005;
char A[Maxn], B[Maxn];
int slen;
bool Less(char A[], int i1, int j1, char B[], int i2, int j2) {
int len = j1 - i1 + 1;
for (int i = 0; i < len; i++)
if (A[i1 + i] != B[i2 + i]) return A[i1 + i] < B[i2 + i];
return false;
}
void Fix(char A[], int l, int r) {
if ((r - l + 1) % 2) return;
int m = l + r >> 1;
Fix(A, l, m);
Fix(A, m + 1, r);
if (Less(A, m + 1, r, A, l, m)) {
int len = r - m;
for (int i = 0; i < len; i++) swap(A[l + i], A[m + 1 + i]);
}
}
int main() {
scanf("%s", A);
scanf("%s", B);
slen = strlen(A);
Fix(A, 0, slen - 1);
Fix(B, 0, slen - 1);
if (Less(A, 0, slen - 1, B, 0, slen - 1) ||
Less(B, 0, slen - 1, A, 0, slen - 1))
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 9 |
#include <iostream>
#include <vector>
#include <string>
int get_ans(std::vector< std::string > & map, int x, int y, int n, int m)
{
int ans = 0;
if (map[x][y] == '*') ans = 1;
if ((x + 1 == n) && (y + 1 == m)) return ans;
if ((x + 1 == n) || ((y < m - 1) && (map[x][y + 1] == '*' || map[x + 1][y] == '.')))
return ans + get_ans(map, x, y + 1, n, m);
else
return ans + get_ans(map, x + 1, y, n, m);
}
void init()
{
int n,m;
std::cin>>n>>m;
std::vector< std::string > map(n, "");
for (int i = 0; i < n; i++) std::cin>>map[i];
std::cout<<get_ans(map, 0, 0, n, m)<<std::endl;
}
int main()
{
init();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 1e17;
const int mod = 998244353;
const long long int N = 600032LL;
long long int fac[N + 2];
long long int inv[N + 2];
long long int add(long long int a, long long int b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
return a;
}
long long int mul(long long int a, long long int b) {
return ((a)*1LL * (b)) % mod;
}
long long int power(long long int a, long long int n) {
long long int res = 1;
while (n) {
if (n & 1) {
res = mul(res, a);
}
n >>= 1, a = mul(a, a);
}
return res;
}
void solve() {
long long int n;
cin >> n;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
vector<long long int> ad[200003];
for (long long int i = 0; i < n; i++) {
ad[1].push_back(1);
long long int op = v[i];
for (int j = 2; j * j <= v[i]; j++) {
if (op % j == 0) {
long long int p = 0;
while (op % j == 0) p++, op /= j;
ad[j].push_back(p);
}
}
if (op > 1) ad[op].push_back(1);
}
long long int ans = 1;
for (int i = 0; i < 200001; i++) {
sort((ad[i]).begin(), (ad[i]).end());
if ((int)ad[i].size() == n) {
ans *= pow(i, ad[i][0]);
ans *= pow(i, ad[i][1] - ad[i][0]);
}
if ((int)ad[i].size() == n - 1) {
ans *= pow(i, ad[i][0]);
}
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
for (int _ = 0; _ < t; _++) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const int N = 1e5 + 1;
using namespace std;
int a[N];
int ans;
int n, x;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
cin >> x;
if (i == n / 2 || j == n / 2 || i == j || n - i == j + 1) ans += x;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, -1, 0, 1};
int dy[4] = {1, 0, -1, 0};
long long MOD = 1e9 + 7;
void solve() {
int n;
cin >> n;
int ax, ay;
cin >> ax >> ay;
int bx, by;
cin >> bx >> by;
int cx, cy;
cin >> cx >> cy;
if (((ax > bx && ax > cx) || (ax < bx && ax < cx)) &&
((ay > by && ay > cy) || (ay < by && ay < cy)))
cout << "YES\n";
else {
cout << "NO\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long test = 1;
while (test--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t N>
int SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
int SIZE(const T &t) {
return t.size();
}
string to_string(const string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void dbgm() { ; }
template <typename Heads, typename... Tails>
void dbgm(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgm(T...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
string s;
cin >> s;
s = "#" + s + "#";
long long count = 0;
string r = s;
if (m == 2) {
string g(n, ' ');
string h(n, ' ');
for (long long i = 0; i < n; i++) {
if (i % 2 == 0) {
g[i] = 'A';
h[i] = 'B';
} else {
g[i] = 'B';
h[i] = 'A';
}
}
long long count1 = 0;
for (long long i = 0; i < n; i++) {
if (s[i + 1] != g[i]) count++;
}
for (long long i = 0; i < n; i++) {
if (s[i + 1] != h[i]) count1++;
}
cout << min(count, count1) << endl;
if (count < count1)
cout << g;
else {
cout << h;
}
return 0;
}
for (long long i = 1, j = 2; i <= n and j <= n + 1;) {
if (s[i] == s[j]) {
j++;
} else {
for (long long k = i + 1; k < j; k += 2) {
count++;
if (s[k + 1] != ((s[k - 1] + 1 - 'A') % m + 'A')) {
s[k] = (s[k] + 1 - 'A') % m + 'A';
} else {
s[k] = (s[k] + 2 - 'A') % m + 'A';
}
}
i = j;
j++;
}
}
cout << count << endl << s.substr(1, n);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 100010;
const int INF = 2147483600;
int N;
int a[MAXN + 1];
bool vis[MAXN + 1];
int dt[1010][1010];
int Mx, sta[MAXN + 1], top;
int ans;
int main() {
N = read();
for (int i = 1; i <= N; i++) a[i] = read();
int precnt = 0;
for (int i = 1; i <= N + 1; i++) {
int mx = 0;
for (int j = 1; j <= N; j++) mx = max(mx, a[j]);
int cnt = 0;
for (int j = 1; j <= N; j++) cnt += (mx == a[j]), vis[j] |= (mx == a[j]);
if (cnt != precnt) {
for (int j = 1; j <= N; j++) vis[j] = 0;
for (int j = 1; j <= N; j++)
if (mx == a[j]) vis[j] = 1;
}
precnt = cnt;
if (cnt >= mx) {
Mx = mx;
break;
}
++ans;
int mn = INF, pos = 0;
for (int j = 1; j <= N; j++) {
if (vis[j]) continue;
if (a[j]) {
if (a[j] < mn) mn = a[j], pos = j;
}
}
for (int j = 1; j <= N; j++)
if (a[j] == mx) --a[j], dt[ans][j] = 1;
if (pos) dt[ans][pos] = 1, a[pos]--, vis[pos] = 1;
}
for (int i = 1; i <= N; i++) {
if (a[i] == Mx) sta[++top] = i;
}
int ls = ans;
for (int i = 1; i <= Mx; i++) {
++ans;
for (int j = 1; j <= top; j++) dt[ans][sta[j]] = 1;
dt[ans][sta[i]] = 0;
}
if (Mx) {
++ans;
for (int j = 1; j <= Mx; j++) dt[ans][sta[j]] = 1;
}
for (int i = 1; i <= N; i++) {
if (a[i] == Mx) continue;
while (a[i]) dt[ls + a[i]][i] = 1, --a[i];
}
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) {
for (int j = 1; j <= N; j++) printf("%d", dt[i][j]);
printf("\n");
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int k, n, arr[501], i, ans = 0;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
for (i = 1; i < n; i++) {
if (arr[i] + arr[i - 1] < k) {
ans += k - arr[i] - arr[i - 1];
arr[i] = k - arr[i - 1];
}
}
printf("%d\n", ans);
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
class Edge {
public:
Edge(int node, char color) : node(node), color(color) {}
void print_node() {
std::cout << "node=" << node << ", color=" << color << std::endl;
}
void print_corresponding() {
std::cout << "node=" << corresponding->node
<< ", color=" << corresponding->color << std::endl;
}
void change_color() { color = (color == 'R') ? 'B' : 'R'; }
int node;
char color;
Edge *corresponding;
};
void print_all_nodes(std::vector<std::vector<Edge *> > &nodes);
int main() {
int32_t n, m, m_tmp;
std::cin >> n >> m;
m_tmp = m;
std::map<char, std::vector<std::vector<Edge *> > > nodes;
nodes['R'].resize(n + 1);
nodes['B'].resize(n + 1);
while (m--) {
int32_t node1, node2;
char color;
std::cin >> node1 >> node2 >> color;
nodes['R'].at(node1).push_back(new Edge(node2, color));
nodes['R'].at(node2).push_back(new Edge(node1, color));
nodes['R'].at(node1).back()->corresponding = nodes['R'].at(node2).back();
nodes['R'].at(node2).back()->corresponding = nodes['R'].at(node1).back();
nodes['B'].at(node1).push_back(new Edge(node2, color));
nodes['B'].at(node2).push_back(new Edge(node1, color));
nodes['B'].at(node1).back()->corresponding = nodes['B'].at(node2).back();
nodes['B'].at(node2).back()->corresponding = nodes['B'].at(node1).back();
}
std::map<char, bool> solved;
std::array<char, 2> colors = {'R', 'B'};
std::map<char, std::vector<int> > change_list;
for (char expected_color : colors) {
std::stack<int> node_stack;
std::vector<bool> is_reached(n + 1, false);
for (int32_t i = 1; i < nodes[expected_color].size(); i++) {
if (is_reached[i]) continue;
auto v = nodes[expected_color].at(i);
std::vector<int> change_list_in_tree;
node_stack.push(i);
std::vector<int> node_in_tree;
while (!node_stack.empty()) {
int32_t node = node_stack.top();
node_stack.pop();
if (is_reached[node]) continue;
node_in_tree.push_back(node);
auto v = nodes[expected_color].at(node);
for (auto edge : v) {
if (edge->color != expected_color) {
change_list_in_tree.push_back(edge->node);
for (auto e : nodes[expected_color].at(edge->node)) {
e->change_color();
e->corresponding->change_color();
}
}
}
is_reached[node] = true;
for (auto edge : v) {
if (!is_reached[edge->node]) node_stack.push(edge->node);
}
}
if (change_list_in_tree.size() > node_in_tree.size() / 2) {
std::sort(begin(node_in_tree), end(node_in_tree));
std::sort(begin(change_list_in_tree), end(change_list_in_tree));
std::set_difference(begin(node_in_tree), end(node_in_tree),
begin(change_list_in_tree),
end(change_list_in_tree),
std::back_inserter(change_list[expected_color]));
} else {
std::copy(begin(change_list_in_tree), end(change_list_in_tree),
std::back_inserter(change_list[expected_color]));
}
}
solved[expected_color] = true;
for (auto node : nodes[expected_color]) {
for (auto edge : node) {
if (edge->color != expected_color) solved[expected_color] = false;
}
}
}
char answer_color;
if (!(solved['R'] || solved['B'])) {
std::cout << -1 << std::endl;
return 0;
} else if (!solved['R']) {
answer_color = 'B';
} else if (!solved['B']) {
answer_color = 'R';
} else {
answer_color =
(change_list['R'].size() > change_list['B'].size()) ? 'B' : 'R';
}
std::cout << change_list[answer_color].size() << std::endl;
if (change_list[answer_color].size() != 0) {
std::cout << change_list[answer_color][0];
for (int i = 1; i < change_list[answer_color].size(); i++) {
std::cout << ' ' << change_list[answer_color][i];
}
std::cout << std::endl;
}
return 0;
}
void print_all_nodes(std::vector<std::vector<Edge *> > &nodes) {
for (int i = 1; i < nodes.size(); i++) {
auto node = nodes.at(i);
std::cout << "node" << (node.front()->corresponding)->node << " start"
<< std::endl;
for (auto e : node) {
std::cout << "self :";
e->print_node();
std::cout << "corresponding:";
e->print_corresponding();
}
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long int t, m, k;
cin >> t >> m >> k;
long long int a[t];
long long int mx = 0;
long long int n = t;
for (long long int i = 0; i < t; i++) {
cin >> a[i];
}
sort(a, a + n);
if (m <= k)
cout << m * a[n - 1] << endl;
else {
long long int temp = m / (k + 1);
long long int ans = temp * (k * a[n - 1] + a[n - 2]);
temp *= k + 1;
temp = m - temp;
ans += temp * a[n - 1];
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 1, 0, -1, -1, -1, 0, 1, 0};
int dy[] = {0, -1, -1, -1, 0, 1, 1, 1, 0};
int sx, sy;
int ex, ey;
char M[8][9];
int main() {
int x, y, nx, ny;
for (int i = 0; i < 8; ++i) {
cin >> M[i];
}
sx = 7;
sy = 0;
ex = 0;
ey = 7;
M[sx][sy] = M[ex][ey] = '.';
bool res = true;
bool vis[8][8] = {0};
vector<pair<int, int> > st, next;
st.push_back(make_pair(sx, sy));
for (int h = 0; h < 8; ++h) {
if (st.empty()) {
res = false;
break;
}
next.clear();
for (int i = 0; i < st.size(); ++i) {
x = st[i].first;
y = st[i].second;
if (M[x][y] == 'S') continue;
for (int j = 0; j < 9; ++j) {
nx = x + dx[j];
ny = y + dy[j];
if (nx < 0 || ny < 0 || nx > 7 || ny > 7) continue;
if (M[nx][ny] == 'S') continue;
if (!vis[nx][ny]) {
next.push_back(make_pair(nx, ny));
vis[nx][ny] = true;
}
}
}
if (vis[ex][ey]) break;
st = next;
for (int j = 7; j >= 0; --j) {
for (int k = 0; k < 8; ++k) {
vis[j][k] = false;
if (M[j][k] == 'S') {
M[j][k] = '.';
if (j < 7) M[j + 1][k] = 'S';
}
}
}
}
if (st.empty()) res = false;
if (res)
cout << "WIN" << endl;
else
cout << "LOSE" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int fx[] = {+1, -1, +0, +0};
const int fy[] = {+0, +0, +1, -1};
const int fx8[] = {+0, +0, +1, -1, -1, +1, -1, +1};
const int fy8[] = {-1, +1, +0, +0, +1, +1, -1, -1};
const int kx[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int ky[] = {-1, 1, -2, 2, -2, 2, -1, 1};
bool isLow(char ch) {
if (ch >= 'a' && ch <= 'z') return true;
return false;
}
bool isUpp(char ch) {
if (ch >= 'A' && ch <= 'Z') return true;
return false;
}
bool isDig(char ch) {
if (ch >= '0' && ch <= '9') return true;
return false;
}
int main() {
int n, ans = 0;
double sum;
cin >> n;
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
sort(A, A + n);
for (int i = 0; i < n; i++) {
if (i % 2 == 0)
ans += (A[i]) * (A[i]);
else
ans -= (A[i]) * (A[i]);
}
ans = abs(ans);
sum = ans * acos(-1.0);
cout << fixed << setprecision(5) << sum << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > vect(500000);
long long counter = 1;
pair<long long, long long> range[500000];
void bfs(long long parent, long long node) {
range[node].first = counter;
for (auto &child : vect[node]) {
if (child != parent) {
bfs(node, child);
}
}
range[node].second = counter;
counter++;
}
bitset<62> tree[4000000];
long long lazy[4000000];
bitset<62> query(bitset<62> tree[], long long l, long long r, long long L,
long long R, long long node) {
if (lazy[node] != 0) {
tree[node].reset();
tree[node][lazy[node]] = 1;
lazy[node * 2] = lazy[node];
lazy[node * 2 + 1] = lazy[node];
lazy[node] = 0;
}
if (l <= L && R <= r) {
return tree[node];
} else if (r < L || R < l) {
bitset<62> temp;
temp.reset();
return temp;
} else {
long long mid;
mid = (L + R) / 2;
bitset<62> temp = query(tree, l, r, L, mid, node * 2);
temp |= query(tree, l, r, mid + 1, R, node * 2 + 1);
tree[node] = tree[node * 2];
tree[node] |= tree[node * 2 + 1];
return temp;
}
}
void update(bitset<62> tree[], long long l, long long r, long long L,
long long R, long long node, long long color) {
if (lazy[node] != 0) {
tree[node].reset();
tree[node][lazy[node]] = 1;
lazy[node * 2] = lazy[node];
lazy[node * 2 + 1] = lazy[node];
lazy[node] = 0;
}
if (l <= L && R <= r) {
tree[node].reset();
tree[node][color] = 1;
lazy[node * 2] = color;
lazy[node * 2 + 1] = color;
lazy[node] = 0;
} else if (r < L || R < l) {
} else {
long long mid;
mid = (L + R) / 2;
update(tree, l, r, L, mid, node * 2, color);
update(tree, l, r, mid + 1, R, node * 2 + 1, color);
tree[node] = tree[node * 2];
tree[node] |= tree[node * 2 + 1];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m;
cin >> n >> m;
long long a[n];
for (long long i = 1; i < n + 1; i++) {
cin >> a[i];
}
memset(lazy, 0, sizeof(lazy));
long long u, v;
for (long long i = 0; i < n - 1; i++) {
cin >> u >> v;
vect[u].push_back(v);
vect[v].push_back(u);
}
bfs(0, 1);
for (long long i = 1; i < n + 1; i++) {
update(tree, range[i].second, range[i].second, 1, n, 1, a[i]);
}
while (m--) {
long long type;
cin >> type;
if (type == 1) {
long long v, c;
cin >> v >> c;
long long l = range[v].first, r = range[v].second;
update(tree, l, r, 1, n, 1, c);
} else {
long long v;
cin >> v;
long long l = range[v].first, r = range[v].second;
bitset<62> ans = query(tree, l, r, 1, n, 1);
cout << ans.count() << "\n";
}
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
double D[1000003], B[1000003], A[1000003];
long long C[2003][2003];
string S;
int main() {
long long T, i, j, k, l, r, s, a, b, c, d, x, y, z, m, n, t, p, q, curr, sum,
ans, pos, val, countA;
cin >> S;
A[0] = 0;
for (i = 1; i < 1000003; i++) {
A[i] = A[i - 1] + 1.0 / i;
}
n = S.size();
B[0] = 0;
for (i = 1; i <= n; i++) {
B[i] = B[i - 1] + 1.0 * (n + 1 - i) / i;
}
double ansR = 0;
for (i = 0; i < n; i++) {
if (S[i] == 'A' || S[i] == 'E' || S[i] == 'I' || S[i] == 'O' ||
S[i] == 'U' || S[i] == 'Y') {
a = i + 1;
b = n - i;
if (a > b) {
t = a;
a = b;
b = t;
}
ansR += a;
ansR += (a) * (A[b] - A[a]);
ansR += B[n] - B[b];
}
}
printf("%lf\n", ansR);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, m;
cin >> n >> k >> m;
map<string, int> mp;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
mp[s] = i;
}
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long> ans(n);
for (int i = 0; i < k; i++) {
int x;
cin >> x;
long long mn = 2e9;
int num[x];
for (int j = 0; j < x; j++) {
cin >> num[j];
num[j]--;
mn = min(mn, a[num[j]]);
}
for (int j = 0; j < x; j++) {
ans[num[j]] = mn;
}
}
long long otv = 0;
for (int i = 0; i < m; i++) {
string str;
cin >> str;
otv += ans[mp[str]];
}
cout << otv << endl;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000000")
using namespace std;
const int MAX_SIZE = 2e5 + 5, INF = 2 * 1e9;
const long long SuperINF = 1e12, MOD = 1e9;
const double eps = 0.5, PI = 20 / 7;
void files() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void solve() {
long long n, k;
cin >> n >> k;
map<long long, long long> used;
if (k >= 1000) {
cout << "No";
return;
}
for (long long i = 1; i <= k; i++) {
if (used[n % i]) {
cout << "No";
return;
}
used[n % i] = 1;
}
cout << "Yes";
}
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
inline void swap(int &a, int &b) {
int tmp = a;
a = b;
b = tmp;
}
inline void swap(long long &a, long long &b) {
long long tmp = a;
a = b;
b = tmp;
}
inline void swap(long double &a, long double &b) {
long double tmp = a;
a = b;
b = tmp;
}
inline long double ABS(const long double &val) { return val < 0 ? -val : val; }
inline long long MAX(const long long &a, const long long &b) {
return a > b ? a : b;
}
inline int MAX(const int &a, const int &b) { return a > b ? a : b; }
inline long long MIN(const long long &a, const long long &b) {
return a < b ? a : b;
}
inline int MIN(const int &a, const int &b) { return a < b ? a : b; }
inline long double MAX(const long double &a, const long double &b) {
return a > b ? a : b;
}
inline long double MIN(const long double &a, const long double &b) {
return a < b ? a : b;
}
const int INTinf = 2147483647;
const int nINTinf = 0 - 2147483648;
using namespace std;
int n, m;
bool met[100005];
int type[100005];
int rtype[100005];
int q, w;
int s1, s2;
long long cnt;
long long con;
int gr;
bool ok;
void rec2(int &q) {
if (rtype[q] != q) {
rec2(rtype[q]);
rtype[q] = s2;
} else {
s2 = q;
if (s1 == s2) {
ok = true;
cnt *= 2;
cnt %= con;
} else
ok = false;
}
}
void rec(int &q) {
if (rtype[q] != q) {
rec(rtype[q]);
rtype[q] = s1;
} else {
s1 = q;
rec2(type[w]);
}
}
int main() {
con = 1e9 + 9;
cnt = 1L;
gr = 1;
cin >> n >> m;
for (int i = 0; i != n; i++) met[i] = false;
for (int i = 0; i != m; i++) {
cin >> q >> w;
if (met[q] == met[w]) {
if (met[q]) {
rec(type[q]);
if (!ok) rtype[rtype[type[q]]] = rtype[type[w]];
} else {
met[q] = met[w] = true;
type[q] = type[w] = rtype[gr] = gr++;
}
} else {
if (met[q]) {
met[w] = true;
type[w] = type[q];
} else {
met[q] = true;
type[q] = type[w];
}
}
cout << cnt - 1L << endl;
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int length[4];
bool check(int a, int b, int c, bool &flag) {
if (c > b) swap(b, c);
if (b > a) swap(a, b);
if (a == b + c) flag = true;
return a < b + c;
}
int main() {
for (int i = 0; i < 4; ++i) cin >> length[i];
bool segment = false;
for (int i = 0; i < 4; ++i)
if (check(length[i], length[(i + 1) % 4], length[(i + 2) % 4], segment))
return puts("TRIANGLE"), 0;
if (segment) return puts("SEGMENT"), 0;
puts("IMPOSSIBLE");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int S[N];
int main() {
int n, m, h;
scanf("%d %d %d", &n, &m, &h);
int sum = 0;
for (int i = 1; i <= m; i++) {
scanf("%d", &S[i]);
sum += S[i];
}
if (sum < n) {
printf("-1\n");
return 0;
}
sum -= S[h];
n--;
double ans = 1;
for (int i = 1; i < S[h]; i++) {
ans *= (double)(sum - n + i) / (sum + i);
}
ans = 1 - ans;
printf("%.12lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
bool f = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
x = f ? -x : x;
}
const int N = 1e5 + 7, M = 2e5 + 7, inf = 1e9 + 7;
int n, m;
int head[N], to[M], nxt[M], w[M], tot;
int col[N];
vector<int> wt[2];
vector<int> c[2];
int cnt[2];
void adde(int u, int v, int l) {
to[++tot] = v;
nxt[tot] = head[u];
head[u] = tot;
w[tot] = l;
}
void clean() {
for (int i = (1), _ = (n); i <= _; ++i) col[i] = -1;
}
bool df(int u, int num) {
col[u] = num;
++cnt[num];
c[num].push_back(u);
for (int i = head[u], v = to[i]; i; i = nxt[i], v = to[i]) {
if (~col[v]) {
if (col[u] ^ w[i] != col[v]) return false;
} else {
if (!df(v, col[u] ^ w[i])) return false;
}
}
return true;
}
int sol0() {
int ans = 0;
clean();
for (int i = (1), _ = (n); i <= _; ++i) {
if (col[i] == -1) {
cnt[0] = cnt[1] = 0;
bool stu = df(i, 0);
if (!stu) {
c[0].clear();
c[1].clear();
return inf;
}
ans += min(cnt[0], cnt[1]);
if (cnt[0] < cnt[1])
for (auto v : c[0]) wt[0].push_back(v);
else
for (auto v : c[1]) wt[0].push_back(v);
c[0].clear();
c[1].clear();
}
}
return ans;
}
bool dfs(int u, int num) {
col[u] = num;
++cnt[num];
c[num].push_back(u);
for (int i = head[u], v = to[i]; i; i = nxt[i], v = to[i]) {
if (~col[v]) {
if (col[u] ^ w[i] ^ 1 != col[v]) return false;
} else {
if (!dfs(v, col[u] ^ w[i] ^ 1)) return false;
}
}
return true;
}
int sol1() {
int ans = 0;
clean();
for (int i = (1), _ = (n); i <= _; ++i) {
if (col[i] == -1) {
cnt[0] = cnt[1] = 0;
bool stu = dfs(i, 0);
if (!stu) {
c[0].clear();
c[1].clear();
return inf;
}
ans += min(cnt[0], cnt[1]);
if (cnt[0] < cnt[1])
for (auto v : c[0]) wt[1].push_back(v);
else
for (auto v : c[1]) wt[1].push_back(v);
c[0].clear();
c[1].clear();
}
}
return ans;
}
signed main() {
read(n);
read(m);
for (int i = (1), _ = (m); i <= _; ++i) {
int x, y;
read(x);
read(y);
char s[5];
scanf("%s", s);
if (s[0] == 'R')
adde(x, y, 0), adde(y, x, 0);
else
adde(x, y, 1), adde(y, x, 1);
}
int ans0 = sol0(), ans1 = sol1();
if (ans1 == ans0 && ans0 == inf)
cout << -1;
else {
if (ans0 < ans1) {
cout << ans0 << endl;
for (auto v : wt[0]) cout << v << ' ';
} else {
cout << ans1 << endl;
for (auto v : wt[1]) cout << v << ' ';
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int N, M, t[100005], ti[100005], stack1[100005], stack2[100005], head[100005],
tov[100005], nxt[100005];
int main() {
int tot = 0;
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) scanf("%d", &t[i]);
for (int i = 1; i <= M; i++) {
int x, y;
scanf("%d%d", &x, &y);
x++;
y++;
ti[x]++;
nxt[i] = head[y];
tov[i] = x;
head[y] = i;
}
int n1 = 0, n2 = 0;
for (int i = 1; i <= N; i++) {
if (ti[i]) continue;
if (t[i])
stack2[++n2] = i;
else
stack1[++n1] = i;
}
while (true) {
if (n1 == 0 && n2 == 0) break;
while (n1) {
int cur = stack1[n1];
int tmp = head[cur];
n1--;
while (tmp) {
int x = tov[tmp];
ti[x]--;
if (ti[x] == 0) {
if (t[x])
stack2[++n2] = x;
else
stack1[++n1] = x;
}
tmp = nxt[tmp];
}
}
if (n2) tot++;
while (n2) {
int cur = stack2[n2];
int tmp = head[cur];
n2--;
while (tmp) {
int x = tov[tmp];
ti[x]--;
if (ti[x] == 0) {
if (t[x])
stack2[++n2] = x;
else
stack1[++n1] = x;
}
tmp = nxt[tmp];
}
}
}
printf("%d\n", tot);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > graph;
vector<int> visited;
int distance(int u, int v) {
visited[u] = true;
if (u == v) {
return 0;
} else {
int k;
for (auto i : graph[u]) {
if (!visited[i]) {
k = distance(i, v);
if (k != -1) {
return k + 1;
}
}
}
return -1;
}
}
vector<int> diam(int u) {
visited[u] = true;
vector<int> res(2);
vector<int> k;
res[0] = -1;
res[1] = u;
for (auto i : graph[u]) {
if (!visited[i]) {
k = diam(i);
res = (res[0] < k[0]) ? k : res;
}
}
res[0]++;
return res;
}
int main() {
int t;
cin >> t;
int n, a, b, da, db;
int u, v;
int d, diameter;
vector<int> temporary;
while (t--) {
cin >> n;
graph.resize(n);
visited.resize(n);
cin >> a >> b >> da >> db;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
graph[u - 1].push_back(v - 1);
graph[v - 1].push_back(u - 1);
}
temporary = diam(0);
for (int i = 0; i < n; i++) {
visited[i] = false;
}
diameter = diam(temporary[1])[0];
for (int i = 0; i < n; i++) {
visited[i] = false;
}
d = distance(a - 1, b - 1);
if (d <= da) {
cout << "Alice" << endl;
} else if (2 * da >= diameter) {
cout << "Alice" << endl;
} else if (db <= 2 * da) {
cout << "Alice" << endl;
} else {
cout << "Bob" << endl;
}
graph.clear();
visited.clear();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool kt(long long xx) {
long long ii, jj;
jj = int(sqrt(xx));
for (ii = 3; ii <= jj; ii = ii + 2)
if ((xx % ii) == 0) {
return false;
}
return true;
}
int main() {
long kq, dkq, f[12000];
int n, m, i, j, p, q, i1, i2, i3, i4, i5, i6, i7, i8, i9, dem;
scanf("%d", &n);
dem = 0;
for (i = 1; i <= 9; i = i + 2) {
for (i1 = 1; i1 <= 9; i1 = i1 + 2) {
kq = i * 10 + i1;
dkq = i1 * 10 + i;
if (kt(kq) == true && kt(dkq) == true && kq != dkq) {
dem++;
f[dem] = kq;
}
}
}
for (i = 1; i <= 9; i = i + 2) {
for (i1 = 0; i1 <= 9; i1 = i1 + 1) {
for (i2 = 1; i2 <= 9; i2 = i2 + 2) {
kq = i * 100 + i1 * 10 + i2;
dkq = i2 * 100 + i1 * 10 + i;
if (kt(kq) == true && kt(dkq) == true && kq != dkq) {
dem++;
f[dem] = kq;
}
}
}
}
for (i = 1; i <= 9; i = i + 2) {
for (i1 = 0; i1 <= 9; i1 = i1 + 1) {
for (i2 = 0; i2 <= 9; i2 = i2 + 1) {
for (i3 = 1; i3 <= 9; i3 = i3 + 2) {
kq = i * 1000 + i1 * 100 + i2 * 10 + i3;
dkq = i3 * 1000 + i2 * 100 + i1 * 10 + i;
if (kt(kq) == true && kt(dkq) == true && kq != dkq) {
dem++;
f[dem] = kq;
}
}
}
}
}
for (i = 1; i <= 9; i = i + 2) {
for (i1 = 0; i1 <= 9; i1 = i1 + 1) {
for (i2 = 0; i2 <= 9; i2 = i2 + 1) {
for (i3 = 0; i3 <= 9; i3 = i3 + 1) {
for (i4 = 1; i4 <= 9; i4 = i4 + 2) {
kq = i * 10000 + i1 * 1000 + i2 * 100 + i3 * 10 + i4;
dkq = i4 * 10000 + i3 * 1000 + i2 * 100 + i1 * 10 + i;
if (kt(kq) == true && kt(dkq) == true && kq != dkq) {
dem++;
f[dem] = kq;
}
}
}
}
}
}
for (i = 1; i <= 9; i = i + 2) {
for (i1 = 0; i1 <= 9; i1 = i1 + 1) {
for (i2 = 0; i2 <= 9; i2 = i2 + 1) {
for (i3 = 0; i3 <= 9; i3 = i3 + 1) {
for (i4 = 0; i4 <= 9; i4 = i4 + 1) {
for (i5 = 1; i5 <= 9; i5 = i5 + 2) {
kq =
i * 100000 + i1 * 10000 + i2 * 1000 + i3 * 100 + i4 * 10 + i5;
dkq =
i5 * 100000 + i4 * 10000 + i3 * 1000 + i2 * 100 + i1 * 10 + i;
if (kt(kq) == true && kt(dkq) == true && kq != dkq) {
dem++;
f[dem] = kq;
}
if (dem > 11184) {
printf("%d", f[n]);
return 0;
}
}
}
}
}
}
}
for (i = 1; i <= 9; i = i + 2) {
for (i1 = 0; i1 <= 9; i1 = i1 + 1) {
for (i2 = 0; i2 <= 9; i2 = i2 + 1) {
for (i3 = 0; i3 <= 9; i3 = i3 + 1) {
for (i4 = 0; i4 <= 9; i4 = i4 + 1) {
for (i5 = 0; i5 <= 9; i5 = i5 + 1) {
for (i6 = 1; i6 <= 9; i6 = i6 + 2) {
kq = i * 1000000 + i1 * 100000 + i2 * 10000 + i3 * 1000 +
i4 * 100 + i5 * 10 + i6;
dkq = i6 * 1000000 + i5 * 100000 + i4 * 10000 + i3 * 1000 +
i2 * 100 + i1 * 10 + i;
if (kt(kq) == true && kt(dkq) == true && kq != dkq) {
dem++;
f[dem] = kq;
}
if (dem > 11184) {
printf("%d", f[n]);
return 0;
}
}
}
}
}
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
void solve() {
int m, n, o;
m = a + b - c;
n = b + c - a;
o = a + c - b;
if (m < 0 || n < 0 || o < 0 || m % 2 != 0 || n % 2 != 0 && o % 2 != 0) {
cout << "Impossible\n";
return;
}
cout << m / 2 << " " << n / 2 << " " << o / 2 << endl;
}
void input() {
int i;
while (cin >> a >> b >> c) {
solve();
}
}
int main() {
input();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
template <class num>
inline void rd(num &x) {
char c;
while (isspace(c = getchar()))
;
bool neg = false;
if (!isdigit(c))
neg = (c == '-'), x = 0;
else
x = c - '0';
while (isdigit(c = getchar())) x = (x << 3) + (x << 1) + c - '0';
if (neg) x = -x;
}
int n;
const int N = 212345;
int l[N], r[N];
struct cmp {
bool operator()(int i, int j) {
if (r[i] != r[j])
return r[i] > r[j];
else
return i < j;
}
};
set<int, cmp> tr[N << 2];
vector<int> tmp;
void get(int i, int l, int r, int mxl, int mnr) {
if (l > mxl) return;
if (r <= mxl) {
for (int j : tr[i])
if (::r[j] >= mnr)
tmp.push_back(j);
else
break;
return;
}
int m = (l + r) / 2;
get(2 * i, l, m, mxl, mnr);
get(2 * i + 1, m + 1, r, mxl, mnr);
}
void add(int i, int l, int r, int pi, bool ad) {
if (ad)
tr[i].insert(pi);
else
tr[i].erase(pi);
if (l == r) return;
int m = (l + r) / 2;
if (::l[pi] <= m)
add(2 * i, l, m, pi, ad);
else
add(2 * i + 1, m + 1, r, pi, ad);
}
int S[N];
int find(int i) {
if (S[S[i]] != S[i]) S[i] = find(S[i]);
return S[i];
}
void join(int a, int b) {
((void)0);
if ((a = find(a)) == (b = find(b))) return;
((void)0);
if (a < b) swap(a, b);
S[b] = a;
}
int ur[N];
struct cmp2 {
bool operator()(int i, int j) {
if (ur[i] != ur[j])
return ur[i] < ur[j];
else
return i < j;
}
};
int d[N], f[N], tempo;
vector<int> adj[N];
int c[N], cn;
void dfs(int u) {
d[u] = tempo++;
for (int v : adj[u]) dfs(v);
f[u] = tempo++;
((void)0);
}
inline bool pai(int u, int p) {
((void)0);
return d[u] >= d[p] && f[u] <= f[p];
}
int op[N], ul[N];
int mp[N], mn;
int main() {
int i, j;
rd(n);
for (i = 0; i < n; i++) {
rd(op[i]);
rd(l[i]);
rd(r[i]);
l[i]--;
r[i]--;
if (op[i] == 1) {
mp[mn++] = i;
c[cn++] = l[i] + modn;
c[cn++] = r[i] + modn;
S[i] = i;
}
}
sort(c, c + cn);
cn = unique(c, c + cn) - c;
set<int, cmp2> mx;
for (i = 0; i < n; i++) {
if (op[i] == 2) continue;
ul[i] = l[i] = lower_bound(c, c + cn, l[i] + modn) - c;
ur[i] = r[i] = lower_bound(c, c + cn, r[i] + modn) - c;
((void)0);
ur[n] = l[i];
for (auto it = mx.upper_bound(n); it != mx.end() && ul[*it] < r[i];) {
adj[i].push_back(*it);
((void)0);
ul[i] = min(ul[i], ul[*it]);
ur[i] = max(ur[i], ur[*it]);
it = mx.erase(it);
}
mx.insert(i);
}
for (int x : mx) dfs(x);
mx.clear();
for (i = 0; i < n; i++) {
if (op[i] == 1) {
tmp.clear();
get(1, 0, cn - 1, l[i] - 1, l[i] + 1);
for (int x : tmp) add(1, 0, cn - 1, x, false), join(i, x);
tmp.clear();
get(1, 0, cn - 1, r[i] - 1, r[i] + 1);
for (int x : tmp) add(1, 0, cn - 1, x, false), join(i, x);
l[i] = ul[i];
r[i] = ur[i];
add(1, 0, cn - 1, i, true);
} else {
((void)0);
if (pai(find(mp[l[i]]), find(mp[r[i]])))
puts("YES");
else
puts("NO");
}
}
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, b[5], a[100005], dp[100005][5];
cin >> n >> b[1] >> b[2] >> b[3];
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i <= n; i++) {
dp[i][0] = 0;
for (int j = 1; j <= 3; j++) dp[i][j] = -0x3f3f3f3f3f3f3f3f;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 3; j++)
dp[i][j] = max(dp[i][j], max(dp[i - 1][j], dp[i][j - 1] + a[i] * b[j]));
cout << dp[n][3] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, w, b, f[2][4005], C[4005][4005], ans;
long long calcmod(long long k) {
long long i, res;
for (i = res = 1; i <= k; i++) res = res * i % 1000000009;
return res;
}
int main() {
long long i, j;
scanf("%I64d%I64d%I64d", &n, &w, &b);
memset(C, 0, sizeof(C));
for (i = 0; i < 4005; i++) C[i][0] = 1;
for (i = 1; i < 4005; i++)
for (j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000009;
f[0][1] = calcmod(w);
f[1][1] = calcmod(b);
for (i = 2; i <= w; i++) f[0][i] = f[0][1] * C[w - 1][i - 1] % 1000000009;
for (i = 2; i <= b; i++) f[1][i] = f[1][1] * C[b - 1][i - 1] % 1000000009;
ans = 0;
for (i = 2; i <= n - 1; i++)
ans = (ans + f[0][i] * (i - 1) % 1000000009 * f[1][n - i] % 1000000009) %
1000000009;
printf("%I64d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <typename T>
void ia(T a[], int n) {
for (int i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void pa(T a[], int n) {
for (int i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
template <typename T>
T gcd(T a, T b) {
if (!b) return a;
return gcd(b, a % b);
}
template <typename T>
T POW(T b, T p) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = POW(b, p / 2);
return s * s;
}
return b * POW(b, p - 1);
}
int main() {
int n;
cin >> n;
int a[10000];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
swap(a[0], a[n - 1]);
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
long long f[5005] = {1, 1}, I[5005] = {1, 1}, J[5005] = {1, 1};
void pre() {
for (int k(2); k < 5005; k++)
f[k] = f[k - 1] * k % (1000000007),
J[k] =
-(1000000007) / k * J[(1000000007) % k] % (1000000007) + (1000000007),
I[k] = I[k - 1] * J[k] % (1000000007);
;
}
long long C(int N, int K) {
return N < K ? 0 : (f[N] * I[K] % (1000000007)) * I[N - K] % (1000000007);
}
char s[5005];
int S, N, a;
long long dp[5005][27];
int main(void) {
pre();
scanf("%d%s", &N, s);
for (int i(0); i < N; i++) {
for (int j = i; j; --j)
a = j ? (dp[j - 1][26] - dp[j - 1][s[i] - 97] + (1000000007)) %
(1000000007)
: 0 + 1,
dp[j][26] += (1000000007) - dp[j][s[i] - 97], dp[j][s[i] - 97] = a,
dp[j][26] += a, dp[j][26] %= (1000000007);
if (!dp[0][s[i] - 97]) dp[0][s[i] - 97] = 1, ++dp[0][26];
}
for (int i(0); i < N; i++) S = (S + C(N - 1, i) * dp[i][26]) % (1000000007);
printf("%d\n", S);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &first) {
first = 0;
while (1) {
char ch = getchar();
if (ch == ' ' || ch == '\n') break;
first = first * 10 + ch - '0';
}
}
inline void write(int first) {
char wr[12];
int k = 0;
if (!first) ++k, wr[k] = '0';
while (first) {
++k;
wr[k] = char(first % 10 + '0');
first /= 10;
}
for (int i = k; i >= 1; --i) putchar(wr[i]);
}
const int N = 1e6 + 100;
int n, c1, c2, T, pref[N], suff[N], mx;
char ch;
bool a[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> c1 >> c2 >> T;
for (int i = 1; i <= n; ++i) {
cin >> ch;
a[i] = (ch == 'w');
}
for (int i = 1; i <= n; ++i) a[i + n] = a[i];
for (int i = 1; i <= n + n; ++i) pref[i] = pref[i - 1] + a[i] * c2 + 1 + c1;
for (int i = n + n; i >= 1; --i) suff[i] = suff[i + 1] + a[i] * c2 + 1 + c1;
int time = T;
for (int i = n + 1; i <= n + n; ++i) {
int cur = pref[i] - pref[n] - c1;
if (cur <= T) {
int kol = i - (n + 1) + 1;
mx = max(mx, kol);
int tmp = cur + (kol - 1) * c1;
if (tmp <= T) {
int l = i - n + 1, r = n;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (suff[mid] - suff[n + 1] + tmp <= T)
r = mid;
else
l = mid;
}
if (suff[l] - suff[n + 1] + tmp <= T)
kol += n + 1 - l;
else if (suff[r] - suff[n + 1] + tmp <= T)
kol += n + 1 - r;
mx = max(mx, kol);
}
}
}
reverse(a + 2, a + n + 1);
for (int i = 1; i <= n; ++i) a[i + n] = a[i];
for (int i = 1; i <= n + n; ++i) pref[i] = pref[i - 1] + a[i] * c2 + 1 + c1;
for (int i = n + n; i >= 1; --i) suff[i] = suff[i + 1] + a[i] * c2 + 1 + c1;
time = T;
for (int i = n + 1; i <= n + n; ++i) {
int cur = pref[i] - pref[n] - c1;
if (cur <= T) {
int kol = i - (n + 1) + 1;
mx = max(mx, kol);
int tmp = cur + (kol - 1) * c1;
if (tmp <= T) {
int l = i - n + 1, r = n;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (suff[mid] - suff[n + 1] + tmp <= T)
r = mid;
else
l = mid;
}
if (suff[l] - suff[n + 1] + tmp <= T)
kol += n + 1 - l;
else if (suff[r] - suff[n + 1] + tmp <= T)
kol += n + 1 - r;
mx = max(mx, kol);
}
}
}
cout << mx;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void faster(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long arr[150009];
int32_t main() {
long long test;
scanf("%lld", &test);
while (test--) {
long long n;
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
}
long long mn = arr[n];
long long cnt = 0;
for (long long i = n - 1; i >= 1; i--) {
if (arr[i] > mn) {
cnt++;
}
mn = min(mn, arr[i]);
}
printf("%lld", cnt), printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace {
using uint = unsigned int;
using edge = tuple<uint, uint>;
using edgecol = vector<edge>;
inline tuple<size_t, size_t> ordtuple(size_t left, size_t right) {
left = min(left, static_cast<size_t>(2));
right = min(right, static_cast<size_t>(2));
if (left <= right)
return make_tuple(left, right);
else
return make_tuple(right, left);
}
int find_node(const edgecol &edges, uint nodes) {
using nodeset = unordered_set<uint>;
using concol = vector<nodeset>;
using candmap = multimap<tuple<size_t, size_t>, uint>;
using itercol = vector<candmap::iterator>;
concol dir_cons(nodes);
concol rev_cons(nodes);
candmap cands;
itercol iters(nodes, end(cands));
for (const auto &e : edges) {
auto &dir_con = dir_cons[get<0>(e) - 1];
auto &rev_con = rev_cons[get<1>(e) - 1];
dir_con.insert(get<1>(e));
rev_con.insert(get<0>(e));
}
for (uint i = 1; i <= nodes; ++i) {
if (dir_cons[i - 1].find(i) == end(dir_cons[i - 1])) {
iters[i - 1] = cands.insert(make_pair(
ordtuple(dir_cons[i - 1].size(), rev_cons[i - 1].size()), i));
}
}
while (!cands.empty()) {
auto iter = begin(cands);
const auto n = iter->second;
cands.erase(iter);
auto &dir_con = dir_cons[n - 1];
auto &rev_con = rev_cons[n - 1];
if (dir_con.size() > 1 && rev_con.size() > 1) break;
for (auto nxt : dir_con) {
assert(nxt != n);
auto &nxt_rev_con = rev_cons[nxt - 1];
nxt_rev_con.erase(n);
for (auto pvs : rev_con) nxt_rev_con.insert(pvs);
}
for (auto pvs : rev_con) {
assert(pvs != n);
auto &pvs_dir_con = dir_cons[pvs - 1];
pvs_dir_con.erase(n);
for (auto nxt : dir_con) pvs_dir_con.insert(nxt);
}
for (auto nxt : dir_con) {
if (iters[nxt - 1] != end(cands)) {
if (dir_cons[nxt - 1].find(nxt) == end(dir_cons[nxt - 1])) {
const auto t =
ordtuple(dir_cons[nxt - 1].size(), rev_cons[nxt - 1].size());
if (t != iters[nxt - 1]->first) {
cands.erase(iters[nxt - 1]);
iters[nxt - 1] = cands.insert(make_pair(t, nxt));
}
} else {
cands.erase(iters[nxt - 1]);
iters[nxt - 1] = end(cands);
}
}
}
for (auto nxt : rev_con) {
if (iters[nxt - 1] != end(cands)) {
if (dir_cons[nxt - 1].find(nxt) == end(dir_cons[nxt - 1])) {
const auto t =
ordtuple(dir_cons[nxt - 1].size(), rev_cons[nxt - 1].size());
if (t != iters[nxt - 1]->first) {
cands.erase(iters[nxt - 1]);
iters[nxt - 1] = cands.insert(make_pair(t, nxt));
}
} else {
cands.erase(iters[nxt - 1]);
iters[nxt - 1] = end(cands);
}
}
}
dir_cons[n - 1].clear();
rev_cons[n - 1].clear();
}
int res = -1;
for (uint p = 1; p <= nodes; ++p) {
if (dir_cons[p - 1].size() >= 1) {
if (res == -1)
res = p;
else
return -1;
}
}
if (res != -1)
return res;
else
return 1;
}
} // namespace
int main() {
ios::sync_with_stdio(false);
uint n = 0;
uint m = 0;
scanf("%u %u", &n, &m);
edgecol edges;
edges.reserve(m);
for (uint i = 0; i < m; ++i) {
edges.emplace_back();
scanf("%u %u", &get<0>(edges.back()), &get<1>(edges.back()));
}
printf("%d\n", find_node(edges, n));
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
long long t;
long long X, Y, x1, x2;
long long mxbit(long long x) {
long long cnt = 0;
while (x > 0) {
cnt++;
x >>= 1;
}
return cnt - 1;
}
long long rev(long long x) {
long long k = mxbit(x), re = 0;
for (long long i = 0; i <= k; i++) {
re |= (1LL << i) * bool((1LL << (k - i)) & x);
}
return re;
}
bool ck(long long x) {
long long tmp = mxbit(x);
long long tmp2 = mxbit(Y);
if (tmp > tmp2) return false;
for (long long i = 0; i < tmp2 - tmp; i++) {
x <<= 1LL;
x |= 1LL;
}
if (x == Y) return true;
for (long long i = tmp2; i > tmp; i--) {
x >>= 1;
x |= 1LL << tmp2;
if (x == Y) return true;
}
return false;
}
int main() {
t = 1;
while (t--) {
cin >> X >> Y;
if (X == Y)
cout << "YES\n";
else {
if (mxbit(X) < mxbit(Y)) {
x1 = (X << 1) | 1;
x2 = rev(x1);
if (ck(x1) || ck(x2)) {
cout << "YES\n";
continue;
}
}
x1 = X;
while (!(x1 & 1)) x1 >>= 1;
x2 = rev(x1);
if (ck(x1) || ck(x2)) {
cout << "YES\n";
continue;
}
cout << "NO\n";
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
map<long long, long long> m;
long long((a)[(n)]);
for (long long i = 0; i < (n); i++) cin >> ((a)[i]);
long long sum = 0;
for (long long(i) = 0; (i) < (n); (i)++) {
while (a[i] > 0 && m[a[i]]) a[i]--;
sum += a[i];
m[a[i]] = 1;
}
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x;
cin >> n >> k;
map<int, long long> M[4];
for (int i = 0; i < n; i++) {
cin >> x;
if (x % k == 0) {
M[3][x] += M[2][x / k];
M[2][x] += M[1][x / k];
}
M[1][x]++;
}
long long sum = 0;
for (map<int, long long>::iterator it = M[3].begin(); it != M[3].end();
it++) {
sum += it->second;
}
cout << sum;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, x1, x2, z = 0;
cin >> x;
x1 = 8;
x2 = x - x1;
for (int i = 2; i < x2 - 1; i++) {
if (x2 % i == 0) {
z++;
}
}
if (z == 0) {
x2 = x2 - 1;
x1 = x1 + 1;
}
cout << x1 << endl << x2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> L >> R;
if (L == R)
cout << L << endl;
else
cout << 2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const long double PI = 3.14159265358979323;
long long int linf = (long long int)2e18;
const int inf = 1011111111;
const int N = 205;
int n, k;
int dp[N][N][N];
string str1, str2;
void input() {
cin >> n >> k >> str1 >> str2;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
for (int k = 0; k <= n; k++) dp[i][j][k] = -inf;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int test = 1;
while (test--) {
input();
dp[0][0][0] = 0;
for (int i = 0; i < n; i++) {
for (int ck = 0; ck <= k; ck++) {
for (int ct = 0; ct <= n; ct++) {
if (dp[i][ck][ct] == -inf) continue;
int e0 = (str1[i] == str2[0]);
int e1 = (str1[i] == str2[1]);
int e01 = (str2[0] == str2[1]);
dp[i + 1][ck][ct + e0] =
max(dp[i + 1][ck][ct + e0], dp[i][ck][ct] + (e1 ? ct : 0));
if (ck < k) {
dp[i + 1][ck + 1][ct + 1] =
max(dp[i + 1][ck + 1][ct + 1], dp[i][ck][ct] + (e01 ? ct : 0));
dp[i + 1][ck + 1][ct + e01] =
max(dp[i + 1][ck + 1][ct + e01], dp[i][ck][ct] + ct);
}
}
}
}
int ans = 0;
for (int ck = 0; ck <= k; ck++) {
for (int ct = 0; ct <= n; ct++) ans = max(ans, dp[n][ck][ct]);
}
cout << ans << "\n";
}
cerr << '\n'
<< "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n";
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 64;
const int M = 1900;
struct RecordType {
int b, c;
} rec[N][32][M];
int dp[N][32][M];
int n;
int arr[N];
bool mydp[M], ans[N][N];
inline bool DP(int x) {
for (int i = 1; i <= x; i++) memset(dp, 0, sizeof(dp));
;
dp[0][0][0] = 1;
int Minlose, tmp, totwin = x * (x - 1) / 2, g;
for (int i = 0; i < x; i++) {
g = i * (i - 1) / 2;
tmp = g + (x - i) * i;
for (int j = 0; j <= min(i, n); j++)
for (int k = g; k <= tmp; k++)
if (dp[i][j][k]) {
Minlose = max(0, k - g - i * (x - i - 1));
if (j == 0)
dp[i + 1][1][k + arr[1]] = 1;
else {
if (Minlose <= x - 1 - arr[j]) dp[i + 1][j][k + arr[j]] = 1;
if (Minlose <= x - 1 - arr[j + 1])
dp[i + 1][j + 1][k + arr[j + 1]] = 1;
}
}
}
return dp[x][n][totwin];
}
inline void getpath(int x) {
for (int i = 1; i <= x; i++) memset(dp, 0, sizeof(dp));
;
dp[0][0][0] = 1;
int Minlose, tmp, totwin = x * (x - 1) / 2, g;
for (int i = 0; i < x; i++) {
g = i * (i - 1) / 2;
tmp = g + (x - i) * i;
for (int j = 0; j <= min(i, n); j++)
for (int k = g; k <= tmp; k++)
if (dp[i][j][k]) {
Minlose = max(0, k - g - i * (x - i - 1));
if (j == 0) {
dp[i + 1][1][k + arr[1]] = 1;
rec[i + 1][1][k + arr[1]] = (RecordType){0, k};
} else {
if (Minlose <= x - 1 - arr[j]) {
dp[i + 1][j][k + arr[j]] = 1;
rec[i + 1][j][k + arr[j]] = (RecordType){j, k};
}
if (Minlose <= x - 1 - arr[j + 1]) {
dp[i + 1][j + 1][k + arr[j + 1]] = 1;
rec[i + 1][j + 1][k + arr[j + 1]] = (RecordType){j, k};
}
}
}
}
}
inline void solve(int x) {
int e = n, f = x * (x - 1) / 2;
RecordType nxt;
vector<pair<int, int> > vv;
for (int i = x; i >= 1; i--) {
vv.push_back(make_pair(f - rec[i][e][f].c, i - 1));
nxt = rec[i][e][f];
e = nxt.b;
f = nxt.c;
}
for (int i = 0; i < x; i++) {
sort(vv.begin(), vv.end());
pair<int, int> t = vv[0];
vv.erase(vv.begin());
for (int j = 0; j < t.first; j++) ans[t.second][vv[j].second] = 1;
for (int j = t.first; j < (int)vv.size(); j++) {
ans[vv[j].second][t.second] = 1;
vv[j].first--;
}
}
printf("%d\n", x);
for (int i = 0; i < x; i++) {
for (int j = 0; j < x; j++) printf("%d", ans[i][j]);
puts("");
}
}
int main() {
int sum = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]), sum += arr[i];
if (n == 1 && arr[1] == 0) {
printf("%d\n%d\n", 1, 0);
return 0;
}
sort(arr + 1, arr + n + 1);
mydp[0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j < M - arr[i]; j++) mydp[j + arr[i]] |= mydp[j];
for (int j = M - sum - 1; j >= 0; j--)
if (mydp[j]) {
mydp[j + sum] = 1;
mydp[j] = 0;
}
for (int i = n; i <= 61; i++)
if (mydp[i * (i - 1) / 2] && DP(i)) {
getpath(i);
solve(i);
return 0;
}
puts("=(");
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
map<long long, bool> d;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
d[a] = 1;
}
int ans = 0;
for (auto i = d.rbegin(); i != d.rend(); i++) {
long long x = i->first;
while (x % 2 == 0 && i->second) {
d[x] = 0;
x /= 2;
d[x] = 1;
ans++;
}
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Op {
int id;
string lhs, rhs;
int lhsid, rhsid;
string op;
};
class TaskE {
public:
void solve(istream& in, ostream& out) {
int n, m;
in >> n >> m;
map<string, int> name_id;
name_id["?"] = n;
vector<Op> v(n);
for (int i = 0; i < n; ++i) {
string trash;
string name;
in >> name >> trash >> v[i].lhs;
v[i].id = i;
name_id[name] = i;
if (v[i].lhs[0] == '0' || v[i].lhs[0] == '1') {
} else {
in >> v[i].op >> v[i].rhs;
v[i].lhsid = name_id[v[i].lhs];
v[i].rhsid = name_id[v[i].rhs];
}
}
vector<int> mn(m, 0), mx(m, 0);
for (int i = 0; i < m; ++i) {
int sum[2] = {0, 0};
for (int p = 0; p < 2; ++p) {
vector<int> val(n + 1);
val[n] = p;
for (int j = 0; j < n; ++j) {
int cur;
if (v[j].op == "") {
cur = v[j].lhs[i];
sum[p] += cur;
} else if (v[j].op == "AND") {
cur = val[v[j].lhsid] & val[v[j].rhsid];
sum[p] += cur;
} else if (v[j].op == "OR") {
cur = val[v[j].lhsid] | val[v[j].rhsid];
sum[p] += cur;
} else if (v[j].op == "XOR") {
cur = val[v[j].lhsid] ^ val[v[j].rhsid];
sum[p] += cur;
} else {
cur = -1;
assert(true);
}
val[v[j].id] = cur;
}
}
if (sum[0] < sum[1]) {
mn[i] = 0;
mx[i] = 1;
} else if (sum[0] == sum[1]) {
mn[i] = mx[i] = 0;
} else if (sum[0] > sum[1]) {
mn[i] = 1;
mx[i] = 0;
}
}
for (int i = 0; i < m; ++i) {
out << mn[i];
}
out << "\n";
for (int i = 0; i < m; ++i) {
out << mx[i];
}
out << "\n";
}
};
int main() {
std::ios::sync_with_stdio(false);
TaskE solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int v[10];
v[0] = 2;
v[1] = 7;
v[2] = 2;
v[3] = 3;
v[4] = 3;
v[5] = 4;
v[6] = 2;
v[7] = 5;
v[8] = 1;
v[9] = 2;
char a, b;
cin >> a >> b;
cout << v[(int)a - '0'] * v[(int)b - '0'] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> n >> m;
vector<vector<int> > bubbles = vector<vector<int> >(n, vector<int>(m, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
cin >> bubbles[i][j];
}
long long ans1 = 0;
for (int p = 0; p < 16; ++p) {
vector<vector<int> > copy = vector<vector<int> >(n, vector<int>(m, 0));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
copy[i][j] = bubbles[i][j];
}
vector<long long> rows = vector<long long>(n, 0);
vector<long long> cols = vector<long long>(m, 0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) rows[i] += bubbles[i][j];
}
for (int j = 0; j < m; ++j) {
for (int i = 0; i < n; ++i) {
cols[j] += bubbles[i][j];
}
}
long long ans = 0;
for (int k = 0; k < 4; ++k) {
if (p & (1 << k)) {
int max_row = 0;
long long max_row_sum = -1;
for (int i = 0; i < n; ++i) {
if (rows[i] > max_row_sum) {
max_row = i;
max_row_sum = rows[i];
}
}
ans += rows[max_row];
for (int j = 0; j < m; ++j) cols[j] -= copy[max_row][j];
for (int j = 0; j < m; ++j) copy[max_row][j] = 0;
rows[max_row] = 0;
} else {
int max_col = 0;
long long max_col_sum = -1;
for (int j = 0; j < m; ++j) {
if (cols[j] > max_col_sum) {
max_col = j;
max_col_sum = cols[j];
}
}
ans += cols[max_col];
for (int i = 0; i < n; ++i) rows[i] -= copy[i][max_col];
for (int i = 0; i < n; ++i) copy[i][max_col] = 0;
cols[max_col] = 0;
}
}
ans1 = max(ans1, ans);
}
cout << ans1 << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<pair<long long, long long> > a(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i].first;
--a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end());
long long mx = -1, mn = n + 1;
for (long long i = 0; i < n; ++i) {
long long t = a[i].second;
mx = max(mx, t);
mn = min(mn, t);
if (mx - mn + 1 == i + 1)
cout << 1;
else
cout << 0;
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> S[110000];
int n, m, q, i, j;
long long a[110000];
long long ans = 0;
vector<int> nums;
long long add[110000];
long long addd[110000];
int per[110000][500];
long long rez[110000];
int r;
int z[110000];
int IN[110000];
const int C = 300;
int main() {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
cin >> r;
for (int j = 0; j < r; j++) {
int x;
cin >> x;
S[i].push_back(x);
rez[i] += a[x];
}
if (r > C) {
nums.push_back(i);
IN[i] = nums.size() - 1;
}
}
for (int num = 0; num < nums.size(); num++) {
int N = nums[num];
for (int i = 0; i < S[N].size(); i++) {
z[S[N][i]] = num + 1;
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < S[i].size(); j++) {
if (z[S[i][j]] == num + 1) per[i][num]++;
}
}
}
for (int tst = 0; tst < q; tst++) {
string ch;
cin >> ch;
if (ch == "+") {
int k;
long long x;
cin >> k >> x;
if (S[k].size() <= C) {
for (int j = 0; j < S[k].size(); j++) a[S[k][j]] += x;
for (int j = 0; j < nums.size(); j++) add[nums[j]] += x * per[k][j];
} else
addd[k] += x;
} else {
int k;
cin >> k;
if (S[k].size() > C) {
long long ans = 0;
ans += add[k] + rez[k];
for (int i = 0; i < nums.size(); i++) ans += addd[nums[i]] * per[k][i];
cout << ans << endl;
} else {
long long ans = 0;
for (int i = 0; i < S[k].size(); i++) {
ans += a[S[k][i]];
}
for (int i = 0; i < nums.size(); i++) ans += addd[nums[i]] * per[k][i];
cout << ans << endl;
}
}
}
return 0;
}
| 17 |
///STOP DOING SILLY MISTAKES
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp> // Common file
//#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define ll long long
#define pb push_back
#define ff first
#define ss second
#define ii insert
#define ld long double
#define sz(x) (int)x.size()
#define all(v) v.begin(),v.end()
#define ppb pop_back
#define nuenxfiu ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL);
#define input freopen("input.txt", "r", stdin),freopen("output.txt", "w", stdout);
#define TT int testcases;cin>>testcases;while(testcases--)
#define mk make_pair
#define MAX ((int)3e5+5)
#define mod ((int)1e9+7)
#define MOD 1000003
#define N ((int)4e6+5)
#define ll long long
int expo(int x,int y){ int res=1; while(y) {if(y%2) res=(res*x%mod)%mod; x=(x*x)%mod; y/=2; } return res;}
int sub(int a, int b) {return (a%mod - b%mod + mod)%mod;}
int mul(int a, int b) {return ((a%mod)*(b%mod) + mod)%mod;}
int inv(int x) {return expo(x, mod-2);}
int fact(int n) {int res = 1;for (int i = 1; i <= n; i++) {res = res * 1ll * i % mod;}return res;}
int fpow(int a, int p) {int res = 1;while (p) {if (p % 2 == 0) {a = a * 1ll * a % mod;p /= 2;} else {res = res * 1ll * a % mod;p--;}}return res;}
int nCr(int n, int k) {return fact(n) * 1ll * fpow(fact(k), mod - 2) % mod * 1ll * fpow(fact(n - k), mod - 2) % mod;}
#define endl "\n"
using namespace std;
// int ans;
// vector<vector<int>>v;
// vector<int>dp,dp1;
bool cmp(vector<int>& a, vector<int>& b){
return a[1]<b[1];
}
void solve()
{
string s;
cin>>s;
set<char>st;
// sort(s.begin(),s.end());
for(int i=0;i<s.size();i++)
st.insert(s[i]);
int n=s.size();
if(st.size()==s.size())
{
int cnt=0;
for(int i=1;i<n-1;i++)
{
if(s[i]>=s[i+1] && s[i]>=s[i-1]){
cnt=1;
cout<<"NO"<<endl;
break;
}
}
sort(s.begin(),s.end());
if(cnt!=1 && s[0]=='a' && s[n-1]==(char)('a'+n-1))
cout<<"YES"<<endl;
else if(cnt!=1 && (s[0]!='a' || s[n-1]!=(char)('a'+n-1)))
cout<<"NO"<<endl;
}
else
cout<<"NO"<<endl;
}
signed main()
{
nuenxfiu
int t;
cin>>t;
while(t--)
{
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
vector<int> depth;
vector<int> recolor;
vector<vector<int>> g;
vector<vector<int>> ng;
vector<vector<long long>> dp;
vector<vector<int>> par;
void dfs(int node, int parent) {
par[node][0] = parent;
if (parent == -1)
depth[node] = 0;
else
depth[node] = depth[parent] + 1;
for (int i = 1; i < 19; ++i)
if (par[node][i - 1] != -1) par[node][i] = par[par[node][i - 1]][i - 1];
for (auto nnode : g[node])
if (nnode != parent) dfs(nnode, node);
}
int find_lca(int a, int b) {
if (depth[a] < depth[b]) swap(a, b);
for (int i = 18; i >= 0; --i)
if (par[a][i] != -1 && depth[par[a][i]] >= depth[b]) a = par[a][i];
if (a == b) return a;
for (int i = 18; i >= 0; --i)
if (par[a][i] != -1 && par[b][i] != -1 && par[a][i] != par[b][i]) {
a = par[a][i];
b = par[b][i];
}
return par[a][0];
}
void calc(int node, int parent) {
if (parent != -1 && ng[node].size() == 1) {
dp[node][0] = 0;
dp[node][1] = 1;
return;
}
for (auto nnode : ng[node])
if (nnode != parent) calc(nnode, node);
if (recolor[node] != 0) {
dp[node][0] = 0;
dp[node][1] = 1;
for (auto nnode : ng[node]) {
if (nnode == parent) continue;
dp[node][1] *= dp[nnode][0] + dp[nnode][1];
dp[node][1] %= MOD;
}
return;
}
long long p = 1;
vector<long long> prod(ng[node].size(), 1);
for (int i = 0; i < ng[node].size(); ++i) {
if (ng[node][i] == parent) continue;
prod[i] = p;
p = p * (dp[ng[node][i]][0] + dp[ng[node][i]][1]) % MOD;
}
dp[node][0] = p;
p = 1;
dp[node][1] = 0;
for (int i = ng[node].size() - 1; i >= 0; --i) {
if (ng[node][i] == parent) continue;
dp[node][1] += prod[i] * p % MOD * dp[ng[node][i]][1] % MOD;
if (dp[node][1] >= MOD) dp[node][1] -= MOD;
p = p * (dp[ng[node][i]][0] + dp[ng[node][i]][1]) % MOD;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (auto& x : a) cin >> x;
g = vector<vector<int>>(n, vector<int>());
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
vector<int> degree(n, 0);
queue<int> q;
for (int i = 0; i < n; ++i) {
degree[i] = g[i].size();
if (a[i] == 0 && degree[i] == 1) q.push(i);
}
vector<bool> deleted(n, false);
while (!q.empty()) {
int node = q.front();
deleted[node] = true;
q.pop();
for (auto& nnode : g[node]) {
if (degree[nnode] > 1) {
--degree[nnode];
if (degree[nnode] == 1 && a[nnode] == 0) {
q.push(nnode);
}
}
}
}
int root = -1;
for (int i = 0; i < n; ++i) {
if (deleted[i]) continue;
root = i;
vector<int> ng;
for (auto nnode : g[i])
if (!deleted[nnode]) ng.push_back(nnode);
g[i] = ng;
}
depth = vector<int>(n);
par = vector<vector<int>>(n, vector<int>(19, -1));
dfs(root, -1);
vector<int> lca(k + 1, -1);
for (int i = 0; i < n; ++i) {
if (deleted[i]) continue;
if (a[i] == 0) continue;
if (lca[a[i]] == -1)
lca[a[i]] = i;
else
lca[a[i]] = find_lca(lca[a[i]], i);
}
vector<bool> marked(n, false);
vector<vector<int>> col_nodes(k + 1, vector<int>());
for (int i = 0; i < n; ++i) {
if (deleted[i]) continue;
col_nodes[a[i]].push_back(i);
}
recolor = vector<int>(n);
for (int col = 1; col <= k; ++col) {
queue<int> q;
for (auto node : col_nodes[col]) {
q.push(node);
recolor[node] = col;
marked[node] = true;
}
while (!q.empty()) {
int node = q.front();
q.pop();
if (node == lca[col]) continue;
int nnode = par[node][0];
if (nnode == -1) continue;
if (a[nnode] != col && a[nnode] != 0) {
cout << 0 << endl;
return 0;
}
if (marked[nnode]) continue;
marked[nnode] = true;
recolor[nnode] = col;
q.push(nnode);
}
}
ng = vector<vector<int>>(n, vector<int>());
for (int i = 0; i < n; ++i) {
if (deleted[i]) continue;
int node = i;
if (recolor[node] != 0) node = lca[recolor[node]];
for (auto j : g[i]) {
int nnode = j;
if (recolor[nnode] != 0) nnode = lca[recolor[nnode]];
if (node != nnode) {
ng[node].push_back(nnode);
}
}
}
dp = vector<vector<long long>>(n, vector<long long>(2, 0));
calc(lca[1], -1);
cout << dp[lca[1]][1] << endl;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
bitset<100010> bs;
vector<int> primes;
void sieve(long long size) {
bs.set();
bs[0] = bs[1] = 0;
for (long long i = 2; i <= size; i++)
if (bs[i]) {
for (long long j = i * i; j <= size; j += i) bs[j] = 0;
primes.push_back((int)i);
}
}
bool isPrime(long long N, long long p) {
for (int i = 0; i < (int)primes.size(); i++) {
if (primes[i] > p) break;
if (N % primes[i] == 0) return false;
}
return true;
}
int main() {
long long p, y, i;
sieve(100008);
cin >> p >> y;
for (i = y; i > p; i--) {
if (isPrime(i, p)) {
cout << i << endl;
return 0;
}
}
cout << "-1\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using ii = pair<int, int>;
using ld = long double;
struct DSU {
vi par, rank, sz;
stack<tuple<int, int, bool>> undo;
DSU(int n) : par(n), rank(n), sz(n, 1) {
iota((par).begin(), (par).end(), 0);
}
void merge(int u, int v) {
u = find(u), v = find(v);
if (u != v) {
if (rank[u] > rank[v]) swap(u, v);
bool b = rank[u] == rank[v];
par[u] = v;
rank[v] += b;
sz[v] += sz[u];
undo.emplace(u, v, b);
}
}
int find(int u) {
while (par[u] != u) u = par[u];
return u;
}
void ctrlz() {
auto [u, v, b] = undo.top();
undo.pop();
par[u] = u;
rank[v] -= b;
sz[v] -= sz[u];
}
void solve(int l, int r, vector<tuple<int, int, int, int>> todo,
vector<vector<ii>>& qrs, vi& ans) {
int init = undo.size();
vector<tuple<int, int, int, int>> push;
for (auto [ul, ur, u, v] : todo) {
if (ul > r || ur < l) {
continue;
} else if (ul <= l && r <= ur) {
merge(u, v);
} else {
push.emplace_back(ul, ur, u, v);
}
}
todo.clear();
if (l == r) {
for (auto [i, v] : qrs[l]) ans[i] = sz[find(v)];
} else {
int m = l + r >> 1;
solve(l, m, push, qrs, ans);
solve(m + 1, r, push, qrs, ans);
}
while (undo.size() > init) ctrlz();
}
};
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
int n, q, d;
cin >> n >> q >> d;
vector<tuple<int, int, int, int>> todo;
vector<vector<ii>> qrs(q + 1);
queue<tuple<int, int, int, int>> wait;
vi ans;
int k = 0, z = 0;
for (int i = 0; i < q; i++) {
int o;
cin >> o;
switch (o) {
case 1: {
int u, v;
cin >> u >> v;
u--, v--;
wait.emplace(u, v, i, k);
} break;
case 2: {
int v;
cin >> v;
v--;
ans.emplace_back();
qrs[i].emplace_back(z++, v);
} break;
case 3: {
k++;
while (!wait.empty()) {
auto [u, v, i_, k_] = wait.front();
if (k_ + d != k) break;
wait.pop();
todo.emplace_back(i_, i, u, v);
}
} break;
}
}
k++;
while (!wait.empty()) {
auto [u, v, i_, k_] = wait.front();
wait.pop();
todo.emplace_back(i_, q, u, v);
}
DSU(n).solve(0, q, todo, qrs, ans);
for (int it : ans) cout << it << '\n';
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int k = 0; k < t; k++) {
int n;
cin >> n;
long long int a[n], b[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) b[i] = a[i];
for (int i = 1; i < n; i++) {
if (a[i - 1] > a[i]) a[i] = a[i - 1];
}
for (int i = 0; i < n; i++) a[i] = a[i] - b[i];
sort(a, a + n);
long long int s = 0;
s = a[n - 1];
if (s == 0) {
cout << 0 << "\n";
continue;
}
long long int x = 0;
while (true) {
if (s == 1 || s == 0)
break;
else {
s = s / 2;
x++;
}
}
if (s == 1) x++;
cout << x << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long sy, a, b;
long long n, q;
long long fenl[N], fenr[N];
long long sum[N];
struct point {
long long x, y;
} p[N];
int main() {
scanf("%lld%lld%lld", &sy, &a, &b);
scanf("%lld", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &fenl[i], &fenr[i]);
sum[i] = sum[i - 1] + fenr[i] - fenl[i];
}
scanf("%lld", &q);
for (int i = 1; i <= q; i++) scanf("%lld%lld", &p[i].x, &p[i].y);
for (int i = 1; i <= q; i++) {
double ans = 0;
double x1 = 1.0 * p[i].x - 1.0 * p[i].y * (p[i].x - a) / (p[i].y - sy);
double x2 = 1.0 * p[i].x - 1.0 * p[i].y * (p[i].x - b) / (p[i].y - sy);
double sp = 1.0 * p[i].y / (p[i].y - sy);
long long L = lower_bound(fenl + 1, fenl + n + 1, x1) - fenl;
long long R = upper_bound(fenr + 1, fenr + n + 1, x2) - fenr;
R -= 1;
ans += 1.0 * (sum[R] - sum[L - 1]) / sp;
if (x1 < fenr[L - 1]) ans += 1.0 * (fenr[L - 1] - x1) / sp;
if (R < n && x2 > fenl[R + 1]) ans += 1.0 * (x2 - fenl[R + 1]) / sp;
printf("%.6llf\n", ans);
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(nullptr);
int n, n1, n2;
cin >> n >> n1 >> n2;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.rbegin(), a.rend());
int k1 = 0, k2 = 0;
long double s1 = 0, s2 = 0;
if (n1 > n2) swap(n1, n2);
for (int i = 0; i < n; ++i) {
if (k1 < n1) {
s1 += a[i];
k1++;
} else if (k2 < n2) {
s2 += a[i];
k2++;
}
}
cout << fixed << setprecision(10) << s1 / k1 + s2 / k2;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long inf = 1e10;
const long long mod = 1e9 + 7;
const long long zero = 0;
const long long maxn = 2e3 + 5;
using namespace std;
long long mat[5][maxn], n, k, cnt;
vector<pair<pair<long long, long long>, long long> > v;
long long dif(long long a, long long b) { return abs(a - b); }
pair<long long, long long> nxt(int i, int j) {
if (i == 2 and j == 1) return {3, 1};
if (i == 3 and j == n) return {2, n};
if (i == 2) return {i, j - 1};
if (i == 3) return {i, j + 1};
}
pair<long long, long long> prev(int i, int j) { return nxt(j, i); }
void find_nxt() {
long long iter1 = -1, iter2 = -1;
for (int i = 1; i <= n; i++) {
if (mat[2][i] == 0) {
iter1 = 2;
iter2 = i;
}
if (mat[3][i] == 0) {
iter1 = 3;
iter2 = i;
}
}
long long l = iter1, r = iter2;
for (int it = 1; it < 2 * n; it++) {
pair<long long, long long> tmp = nxt(l, r);
if (mat[tmp.first][tmp.second]) {
v.push_back(make_pair(make_pair(mat[tmp.first][tmp.second], l), r));
mat[l][r] = mat[tmp.first][tmp.second];
mat[tmp.first][tmp.second] = 0;
}
l = tmp.first;
r = tmp.second;
}
}
void isval() {
for (int i = 1; i <= n; i++) {
if (mat[2][i] and mat[1][i] == mat[2][i]) {
v.push_back(make_pair(make_pair(mat[1][i], 1), i));
mat[2][i] = mat[1][i] = 0;
k--;
}
if (mat[3][i] and mat[3][i] == mat[4][i]) {
v.push_back(make_pair(make_pair(mat[3][i], 4), i));
mat[3][i] = mat[4][i] = 0;
k--;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= n; j++) cin >> mat[i][j];
isval();
if (2 * n == k) {
cout << -1;
return 0;
}
while (k > 0 and cnt <= 499) {
cnt++;
find_nxt();
isval();
}
if (cnt >= 401) {
cout << -1;
return 0;
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i].first.first << " " << v[i].first.second << " " << v[i].second
<< endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
int t[101], n, b, aux, i;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &t[i]);
}
do {
b = 0;
for (i = 1; i <= n - 1; i++) {
if (t[i] > t[i + 1]) {
aux = t[i];
t[i] = t[i + 1];
t[i + 1] = aux;
b++;
}
}
} while (b != 0);
for (i = 1; i <= n; i++) {
printf("%d ", t[i]);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int n, m, ans;
int dr[4] = {-1, 0, 1, 0};
int dc[4] = {0, 1, 0, -1};
int dist[N][N];
char ar[N][N];
bool inRange(int x, int y) {
return ((x >= 1) && (x <= n) && (y >= 1) && (y <= m));
}
int main() {
cin >> n >> m;
pair<int, int> s, me;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> ar[i][j];
if (ar[i][j] == 'E') s = {i, j};
if (ar[i][j] == 'S') me = {i, j};
}
}
memset(dist, -1, sizeof(dist));
dist[s.first][s.second] = 0;
queue<pair<int, int> > q;
q.push(s);
while (!q.empty()) {
pair<int, int> now = q.front();
q.pop();
int r = now.first;
int c = now.second;
for (int i = 0; i < 4; i++) {
int nr = r + dr[i];
int nc = c + dc[i];
if (inRange(nr, nc) && (ar[nr][nc] != 'T')) {
if (dist[nr][nc] == -1) {
dist[nr][nc] = dist[r][c] + 1;
q.push(pair<int, int>(nr, nc));
}
}
}
}
int myDist = dist[me.first][me.second];
ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (('A' <= ar[i][j]) && (ar[i][j] <= 'Z')) continue;
if (dist[i][j] <= myDist && (dist[i][j] != -1))
ans += int(ar[i][j]) - int('0');
}
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int cnt(int a, int b) {
if (!a || !b) return INF;
if (a == 1 && b == 1) return 0;
if (a > b) return cnt(a - b, b) + 1;
return cnt(a, b - a) + 1;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int k = INF;
for (int x = 1; x <= n; x++) k = min(k, cnt(x, n));
cout << k;
return false;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 7;
struct Edge {
int from, to, cap, flow;
Edge(int x = 0, int y = 0, int z = 0, int t = 0)
: from(x), to(y), cap(z), flow(t) {}
};
struct Dinic {
int n;
vector<vector<int> > g;
vector<Edge> e;
vector<int> dist;
vector<int> pos;
Dinic(int n = 0) : n(n) {
e.clear();
g.assign(n, vector<int>());
dist.resize(n);
pos.resize(n);
}
void addEdge(int u, int v, int cap, bool twoway) {
g[u].push_back(e.size());
e.push_back(Edge(u, v, cap, 0));
g[v].push_back(e.size());
e.push_back(Edge(v, u, twoway ? cap : 0, 0));
}
void resetFlow() {
for (unsigned i = 0; i < e.size(); ++i) e[i].flow = 0;
}
bool bfs(int s, int t) {
fill(dist.begin(), dist.end(), -1);
queue<int> q;
q.push(s);
dist[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (__typeof(g[u].begin()) it = g[u].begin(); it != g[u].end(); ++it) {
int v = e[*it].to;
if (dist[v] == -1 && e[*it].flow < e[*it].cap) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
return dist[t] != -1;
}
int dfs(int s, int t, int f) {
if (s == t || !f) return f;
int val;
for (; pos[s] < (int)g[s].size(); pos[s]++) {
Edge& p = e[g[s][pos[s]]];
if (dist[p.to] == dist[p.from] + 1 && p.flow < p.cap) {
if (val = dfs(p.to, t, min(f, p.cap - p.flow))) {
p.flow += val;
e[g[s][pos[s]] ^ 1].flow -= val;
return val;
}
}
}
return 0;
}
int getflow(int s, int t) {
int total = 0;
while (bfs(s, t)) {
int val;
fill(pos.begin(), pos.end(), 0);
while (val = dfs(s, t, INF)) total += val;
}
return total;
}
};
int n, m;
int f[222][222], res[222];
void process() {
scanf("%d%d", &n, &m);
Dinic netWork(n);
for (int i = 0; i < m; ++i) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
netWork.addEdge(u - 1, v - 1, c, 1);
}
memset(f, 0x3f, sizeof(f));
vector<int> p(n, 0);
for (int i = 1; i < n; ++i) {
netWork.resetFlow();
int flow = netWork.getflow(i, p[i]);
for (int j = i + 1; j < n; ++j)
if (netWork.dist[j] >= 0 && p[i] == p[j]) p[j] = i;
f[i][p[i]] = f[p[i]][i] = flow;
for (int j = 0; j < i; ++j) f[i][j] = f[j][i] = min(flow, f[p[i]][j]);
}
vector<bool> used(n, 0);
res[0] = 0;
used[0] = 1;
int total = 0;
for (int i = 1; i < n; ++i) {
int x = -1, cap = -1;
for (int j = 0; j < n; ++j)
if (!used[j] && f[res[i - 1]][j] > cap) cap = f[res[i - 1]][j], x = j;
used[x] = 1;
res[i] = x;
total += cap;
}
printf("%d\n", total);
for (int i = 0; i < n; ++i) printf("%d ", res[i] + 1);
}
int main() {
process();
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
long long a[2222][103];
long long b[2222][103];
long long w[2222][103];
int vis[2222];
long long tmp[2222];
long long kmp[103];
int N;
int main() {
string d;
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
cin >> d;
int k = d.size();
for (int j = 0; j < k; ++j) {
tmp[k - j - 1] = d[j] - '0';
}
for (int n = 0; n <= 70; ++n) {
for (int j = k - 1; j > 0; --j) {
tmp[j - 1] += (tmp[j] & ((1LL << 31) - 1)) * 10LL;
tmp[j] >>= 31;
}
a[i][n] = tmp[0] & ((1LL << 31) - 1);
tmp[0] >>= 31;
}
int D = 31 * 71 - 1;
int idx = -1;
bool maxbitset = false;
for (int n = 0; n <= 70; ++n) kmp[n] = 0;
for (int n = 70; n >= 0; --n) {
for (int j = 30; j >= 0; j--) {
long long p = a[i][n] & (1LL << j);
if (p) {
if (vis[D]) {
for (int m = 0; m <= 70; ++m) {
a[i][m] ^= b[D][m];
kmp[m] ^= w[D][m];
}
} else if (!maxbitset) {
idx = D;
maxbitset = true;
}
}
--D;
}
}
if (!maxbitset) {
int cntr = 0;
for (int y = 0; y <= 70; ++y) {
cntr += __builtin_popcountll(kmp[y]);
}
assert(cntr != 0);
printf("%d", cntr);
int xx = 0;
for (int y = 0; y <= 70; ++y) {
for (int u = 0; u <= 30; ++u) {
if (kmp[y] & (1LL << u)) {
cntr--;
printf(" %d", xx);
}
++xx;
}
}
assert(cntr == 0);
printf("\n");
} else {
assert(idx != -1);
printf("0\n");
for (int y = 0; y <= 70; ++y) {
b[idx][y] = a[i][y];
}
for (int y = 0; y <= 70; ++y) {
w[idx][y] = kmp[y];
}
w[idx][i / 31] ^= (1LL << (i % 31));
vis[idx] = 1;
}
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
const int LIM = 4e6 + 5;
int arr[MAX];
int seg[LIM][2];
int combine(int &a, int &b, int x) {
if (x) {
if (arr[a] > arr[b]) return b;
return a;
}
if (arr[a] > arr[b]) return a;
return b;
}
void build(int t, int i, int j) {
if (i == j) {
seg[t][0] = seg[t][1] = i;
return;
}
int mid = (i + j) / 2;
build(t * 2, i, mid);
build(t * 2 + 1, mid + 1, j);
seg[t][0] = combine(seg[2 * t][0], seg[2 * t + 1][0], 0);
seg[t][1] = combine(seg[2 * t][1], seg[2 * t + 1][1], 1);
}
int query(int t, int i, int j, int l, int r, int x = 0) {
if (l <= i && j <= r) {
return seg[t][x];
}
int mid = (i + j) / 2;
if (l <= mid) {
if (r <= mid) {
return query(t * 2, i, mid, l, r, x);
} else {
int a = query(t * 2, i, mid, l, r, x);
int b = query(t * 2 + 1, mid + 1, j, l, r, x);
return combine(a, b, x);
}
} else {
return query(t * 2 + 1, mid + 1, j, l, r, x);
}
}
int n;
long long recur(int l, int r, int x) {
if (l > r) return 0LL;
int a = query(1, 0, n - 1, l, r, x);
return 1LL * arr[a] * (r - a + 1) * (a - l + 1) + recur(l, a - 1, x) +
recur(a + 1, r, x);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
build(1, 0, n - 1);
printf("%lld\n", recur(0, n - 1, 0) - recur(0, n - 1, 1));
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef pair<int ,int> pii;
typedef pair<ll, ll> pll;
typedef double rl;
typedef pii int2;
typedef tuple<int, int, int> int3;
typedef tuple<int, int, int, int> int4;
typedef tuple<int, int, int, int, int> int5;
typedef pll ll2;
typedef tuple<ll, ll, ll> ll3;
typedef tuple<ll, ll, ll, ll> ll4;
typedef tuple<ll, ll, ll, ll, ll> ll5;
#define g0(x) get<0>(x)
#define g1(x) get<1>(x)
#define g2(x) get<2>(x)
#define g3(x) get<3>(x)
#define g4(x) get<4>(x)
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<ll> vll;
typedef vector<pll> vll_ll;
typedef vector<vi> vvi;
typedef vector<vii> vvii;
typedef vector<vll> vvll;
typedef vector<vll_ll> vvll_ll;
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define xx first
#define yy second
#define FOR(i,N) for(int i=0; i<N; i++)
#define popc __builtin_popcountll
// #define popc __builtin_popcount
template<typename A>
string to_string(A* ptr)
{
stringstream ss; ss << "0x" << std::setw(16) << std::setfill ('0') << std::hex << (uint64_t)(uintptr_t)ptr;
return ss.str();
}
string to_string(char c)
{
return ((string)"'"+c)+ "'";
}
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#if !ONLINE_JUDGE && 0
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define dbg(...) 42
#endif
int solve_dir(vector<int> box_, vector<int> pos_)
{
int n=(int)box_.size(), m=(int)pos_.size();
dbg(box_);
dbg(pos_);
int curr_result=0;
set<int> BOX(box_.begin(), box_.end()), POS(pos_.begin(), pos_.end());
set<int> POS_REM;
auto BOX_ORIG=BOX;
const int INF=1e9+1e7;
for(int p: POS) if(BOX.count(p)) curr_result+=1;
int result=curr_result;
int i=0;
int train=0;
//for( ; todo; todo)
dbg("~~~~~~~~~~~~~~~~~~~~~~");
while(true)
{
dbg("-----------");
dbg(BOX);
dbg(POS);
dbg(POS_REM);
dbg(curr_result);
int box =BOX .empty()?INF:*BOX.begin()-(train+1);
int pos =POS .empty()?INF:*POS.begin()-(train);
int pos_rem=POS_REM.empty()?INF:*POS_REM.begin();
dbg(box, pos, pos_rem);
pii choice1={box, 2};
pii choice2={pos, 1};
pii choice3={pos_rem, 0};
auto [val, type]=min({choice1, choice2, choice3});
dbg(val, type);
if(val>=INF) break;
if(type==0)
{
//train-=1;
if(train>0) curr_result-=1;
POS_REM.erase(POS_REM.begin());
}
else if(type==2)
{
train+=1;
BOX.erase(BOX.begin());
}
else if(type==1)
{
int p=*POS.begin();
if(BOX_ORIG.count(p)==0 && train>0)
{
curr_result+=1;
}
POS_REM.insert(p);
POS.erase(p);
}
else assert(false);
//if(choice.first>=INF) break;
dbg(result);
result=max(result, curr_result);
}
dbg(result);
dbg("===================================");
return result;
}
const int MX=2e5+99;
int n, m, a[MX], b[MX];
int solve()
{
dbg("============");
vector<int> box[2], pos[2];
FOR(i, n)
{
if(a[i]>0) box[0].pb( a[i]);
else box[1].pb(-a[i]);
}
reverse(box[1].begin(), box[1].end());
FOR(i, m)
{
if(b[i]>0) pos[0].pb( b[i]);
else pos[1].pb(-b[i]);
}
reverse(pos[1].begin(), pos[1].end());
int result_pos=solve_dir(box[0], pos[0]);
int result_neg=solve_dir(box[1], pos[1]);
int result=result_pos+result_neg;
return result;
}
int main()
{
#if !ONLINE_JUDGE && 1
freopen("C.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#endif
#if 0
ios_base::sync_with_stdio(false);
cin.tie(nullptr); cout.tie(nullptr);
#endif
int TT;
#if 1
cin >> TT;
#else
TT=1;
#endif
for(int ttt=0; ttt<TT; ttt++)
{
cin >> n >> m;
FOR(i, n) cin >> a[i];
FOR(i, m) cin >> b[i];
cout << solve() << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
long long int n;
cin >> n;
if (n % 2 != 0) {
cout << 0 << endl;
} else {
cout << (1 << n / 2) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n / 100) + ((n % 100) / 20) + (((n % 100) % 20) / 10) +
((((n % 100) % 20) % 10) / 5) + ((((n % 100) % 20) % 10) % 5)
<< endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define all(x) x.begin() , x.end()
#define ld long double
const long long inf = 1e18 + 5LL;
const int mod = 1e9 + 7LL; //998244353 ;
void solve();
void ITO();
int32_t main() {
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); ITO();
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
const int N = (2750131 + 5);
void solve()
{
int n; cin >> n;
int arr[n]; for (auto &x : arr) cin >> x;
int res = 0;
for (int i = 0; i < n - 1; i++)
{
int s = min(arr[i] , arr[i + 1]);
int l = max(arr[i] , arr[i + 1]);
while (l > 2 * s)
{
s = s * 2;
res++;
}
}
cout << res;
cout << "\n";
return ;
}
void ITO()
{
#ifndef ONLINE_JUDGE
freopen("inputf.in", "r", stdin);
freopen("outputf1.in", "w", stdout);
#endif
}
// 🙃
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 128;
vector<int> adj[MAX_N];
void ask(int u) {
cout << "? " << u << endl;
int k;
cin >> k;
adj[u] = vector<int>(k);
for (int i = 0; i < k; i++) {
cin >> adj[u][i];
}
}
void report(int u) { cout << "! " << u << endl; }
bool root(int u) { return adj[u].size() == 2; }
bool leaf(int u) { return adj[u].size() == 1; }
bool seen(int u) { return !adj[u].empty(); }
int unseen_nb(int u) {
for (int v : adj[u]) {
if (!seen(v)) return v;
}
return -1;
}
void solve() {
int h;
cin >> h;
for (int i = 1; i < 1 << h; i++) {
adj[i].clear();
}
deque<int> cur_chain;
do {
if (cur_chain.empty()) {
cur_chain.push_back(1);
ask(1);
if (root(1)) {
report(1);
return;
}
cur_chain.push_back(adj[1][0]);
ask(adj[1][0]);
if (root(adj[1][0])) {
report(adj[1][0]);
return;
}
} else {
int mid = (int)cur_chain.size() / 2 + 1;
while ((int)cur_chain.size() > mid) {
cur_chain.pop_back();
}
}
while (!leaf(cur_chain.front())) {
int u = unseen_nb(cur_chain.front());
ask(u);
if (root(u)) {
report(u);
return;
}
cur_chain.push_front(u);
}
while (!leaf(cur_chain.back())) {
int u = unseen_nb(cur_chain.back());
ask(u);
if (root(u)) {
report(u);
return;
}
cur_chain.push_back(u);
}
} while ((int)cur_chain.size() < 7);
int source = cur_chain[(int)cur_chain.size() / 2];
int reqd = h - (int)cur_chain.size() / 2 - 1;
queue<pair<int, int>> Q;
Q.push({source, 0});
while (Q.front().second < reqd) {
pair<int, int> qtop = Q.front();
Q.pop();
int cur = qtop.first;
int dist = qtop.second;
if (!seen(cur)) {
ask(cur);
}
for (int nxt : adj[cur]) {
if (!seen(nxt)) {
Q.push({nxt, dist + 1});
}
}
}
while (Q.size() >= 2) {
int cur = Q.front().first;
Q.pop();
ask(cur);
if (root(cur)) {
report(cur);
return;
}
}
report(Q.front().first);
}
int main() {
ios::sync_with_stdio(false);
int testc;
cin >> testc;
for (int i = 0; i < testc; i++) {
solve();
}
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
double cal(double h, double w, double a) {
double ans = sin(a) * cos(a);
ans *= ((h * (1 + cos(a)) - w * sin(a)) /
((1 + cos(a)) * (1 + cos(a)) - sin(a) * sin(a))) *
((h * (1 + cos(a)) - w * sin(a)) /
((1 + cos(a)) * (1 + cos(a)) - sin(a) * sin(a)));
return ans;
}
int main() {
double h, w, a;
while (cin >> w >> h >> a) {
int bo = 0;
if (h > w) {
double t = w;
w = h;
h = t;
bo = 1;
}
double b = 2 * atan((h / w));
a = (a / 180) * PI;
if (a < b || (a > (PI - b))) {
if (a > (PI - b)) a = PI - a;
double ans1 = h * w - cal(h, w, a) - cal(w, h, a);
printf("%.8lf\n", ans1);
} else {
double ans2 = (h / (sin(a))) * h;
printf("%.8lf\n", ans2);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e3 + 10;
const long long inf = 1e18;
vector<int> g[maxn];
pair<long long, long long> dp[maxn][maxn], pre[maxn];
int N, M;
long long B[maxn], W[maxn], tsize[maxn];
void DFS(int x, int p) {
tsize[x] = 1;
dp[x][1] = make_pair(0, W[x] - B[x]);
for (int y : g[x]) {
if (y != p) {
DFS(y, x);
for (int i = 1; i <= tsize[x] + tsize[y]; ++i)
pre[i] = make_pair(0, -inf);
for (int i = 1; i <= tsize[x]; ++i) {
for (int j = 1; j <= tsize[y]; ++j) {
pre[i + j] = max(
pre[i + j],
make_pair(dp[x][i].first + dp[y][j].first + (dp[y][j].second > 0),
dp[x][i].second));
pre[i + j - 1] =
max(pre[i + j - 1], make_pair(dp[x][i].first + dp[y][j].first,
dp[x][i].second + dp[y][j].second));
}
}
tsize[x] += tsize[y];
for (int i = 1; i <= tsize[x]; ++i) dp[x][i] = pre[i];
}
}
}
int main() {
int T;
cin >> T;
for (int t = 1; t <= T; ++t) {
cin >> N >> M;
for (int i = 1; i <= N; ++i) cin >> B[i], g[i].clear();
for (int i = 1; i <= N; ++i) cin >> W[i];
for (int i = 1; i < N; ++i) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
DFS(1, 1);
cout << dp[1][M].first + (long long)(dp[1][M].second > 0) << endl;
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int a[100007];
int pref[100007], suff[100007];
struct data {
int l, r, id;
bool operator<(const data& p) const {
if (l / 317 == p.l / 317) return r < p.r;
return l / 317 < p.l / 317;
}
};
data qr[100007];
long long ans[100007];
long long p[4000007], s[4000007];
int main(void) {
int n, m, k, i;
scanf("%d %d %d", &n, &m, &k);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pref[i] = pref[i - 1] ^ a[i];
}
for (i = n; i; i--) suff[i] = suff[i + 1] ^ a[i];
for (i = 0; i < m; i++) {
qr[i].id = i;
scanf("%d %d", &qr[i].l, &qr[i].r);
}
sort(qr, qr + m);
int L, R;
long long cnt;
L = 1;
R = 0;
cnt = 0;
p[0] = 1;
s[suff[1]] = 1;
for (i = 0; i < m; i++) {
while (R < qr[i].r) {
R++;
cnt += p[pref[R] ^ k];
p[pref[R]]++;
s[suff[R + 1]]++;
}
while (qr[i].l < L) {
L--;
cnt += s[suff[L] ^ k];
p[pref[L - 1]]++;
s[suff[L]]++;
}
while (qr[i].r < R) {
p[pref[R]]--;
s[suff[R + 1]]--;
cnt -= p[pref[R] ^ k];
R--;
}
while (L < qr[i].l) {
p[pref[L - 1]]--;
s[suff[L]]--;
cnt -= s[suff[L] ^ k];
L++;
}
ans[qr[i].id] = cnt;
}
for (i = 0; i < m; i++) printf("%lld\n", ans[i]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
vector<int> seen(10, 0);
int cnts = INT_MAX;
for (int i = 0; i < s.length(); ++i) {
seen[s[i] - '0']++;
}
string temp = s;
if (seen[5] && seen[2]) {
int counts = 0;
for (int i = s.length() - 1; i >= 0; --i) {
if (s[i] == '5') {
int j = i;
while (j != s.length() - 1) {
swap(s[j], s[j + 1]);
++j;
counts++;
}
break;
}
}
for (int i = s.length() - 1; i >= 0; --i) {
if (s[i] == '2') {
int j = i;
while (j != s.length() - 2) {
swap(s[j], s[j + 1]);
++j;
counts++;
}
break;
}
}
int i = 0;
while (s[i] == '0') ++i;
counts += i;
cnts = min(cnts, counts);
}
s = temp;
if (seen[7] && seen[5]) {
int counts = 0;
for (int i = s.length() - 1; i >= 0; --i) {
if (s[i] == '5') {
int j = i;
while (j != s.length() - 1) {
swap(s[j], s[j + 1]);
++j;
counts++;
}
break;
}
}
for (int i = s.length() - 1; i >= 0; --i) {
if (s[i] == '7') {
int j = i;
while (j != s.length() - 2) {
swap(s[j], s[j + 1]);
++j;
counts++;
}
break;
}
}
int i = 0;
while (s[i] == '0') ++i;
counts += i;
cnts = min(cnts, counts);
}
s = temp;
if (seen[0] && seen[5]) {
int counts = 0;
for (int i = s.length() - 1; i >= 0; --i) {
if (s[i] == '0') {
int j = i;
while (j != s.length() - 1) {
swap(s[j], s[j + 1]);
++j;
counts++;
}
break;
}
}
for (int i = s.length() - 1; i >= 0; --i) {
if (s[i] == '5') {
int j = i;
while (j != s.length() - 2) {
swap(s[j], s[j + 1]);
++j;
counts++;
}
break;
}
}
int i = 0;
while (s[i] == '0') ++i;
counts += i;
cnts = min(cnts, counts);
}
s = temp;
if (seen[0] > 1) {
int counts = 0;
for (int i = s.length() - 1; i >= 0; --i) {
if (s[i] == '0') {
int j = i;
while (j != s.length() - 1) {
swap(s[j], s[j + 1]);
++j;
counts++;
}
break;
}
}
for (int i = s.length() - 2; i >= 0; --i) {
if (s[i] == '0') {
int j = i;
while (j != s.length() - 2) {
swap(s[j], s[j + 1]);
++j;
counts++;
}
break;
}
}
int i = 0;
while (s[i] == '0') ++i;
counts += i;
cnts = min(cnts, counts);
}
if (cnts == INT_MAX)
cout << -1 << endl;
else
cout << cnts << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long readll() {
bool minus = false;
long long result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = result * 10 + (ch - '0');
}
if (minus)
return -result;
else
return result;
}
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int LEFT = 0, RIGHT = 1;
const int MX = 112345;
char s1[MX], s2[MX];
char ans[MX];
vector<int> common, diff;
char getNewChar(int ind) {
char res = 'a';
for (int(i) = 0; (i) < (int)(26); (i)++) {
res += i;
if (res != s1[ind] && res != s2[ind]) return res;
}
}
int vis[MX];
int main() {
memset(vis, 0, sizeof vis);
int n, t;
scanf("%d%d", &n, &t);
scanf("%s", s1);
scanf("%s", s2);
for (int(i) = 0; (i) < (int)(n); (i)++) {
if (s1[i] == s2[i])
common.push_back(i);
else
diff.push_back(i);
}
if (t == 0) {
if (diff.size() > 0)
puts("-1");
else
printf("%s", s1);
return 0;
}
if (diff.size() > t * 2) return puts("-1"), 0;
int remainDif = diff.size(), remaint = t;
int cnt = 0;
while (remainDif > 0 && remainDif > remaint) {
remainDif -= 2;
remaint--;
cnt = diff.back();
diff.pop_back();
vis[cnt] = true;
ans[cnt] = s1[cnt];
cnt = diff.back();
diff.pop_back();
ans[cnt] = s2[cnt];
vis[cnt] = true;
}
while (remaint > 0 && remainDif > 0) {
remainDif--;
remaint--;
cnt = diff.back();
diff.pop_back();
vis[cnt] = true;
ans[cnt] = getNewChar(cnt);
}
for (int(i) = 0; (i) < (int)(n); (i)++) {
if (!vis[i])
if (remaint > 0) {
remaint--;
ans[i] = getNewChar(i);
} else
ans[i] = s1[i];
}
printf("%s", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int mas[1001], nxt[1001];
bool dp[1002][1002];
vector<int> len;
void go(int sum, int cur) {
if (dp[sum][cur]) return;
dp[sum][cur] = true;
if (cur == len.size()) return;
for (int i = cur; i < len.size(); i++) go(sum + len[i], i + 1);
}
int main() {
int n, x;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> mas[i];
nxt[mas[i]] = i;
}
int cnt1 = 0;
int t = x;
while (t != 0) {
cnt1++;
t = mas[t];
}
for (int i = 1; i <= n; i++) {
if (nxt[i] == 0) {
int cnt = 0, k = i;
if (k == x) continue;
while (k != 0) {
if (k == x) {
cnt = -1;
break;
}
cnt++;
k = mas[k];
}
if (cnt != -1) len.push_back(cnt);
}
}
sort(len.begin(), len.end());
go(cnt1, 0);
for (int i = 1; i <= n; i++) {
bool can = false;
for (int j = 0; j <= n; j++) can |= dp[i][j];
if (can) cout << i << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rang(
chrono::high_resolution_clock::now().time_since_epoch().count());
long long power(long long x, long long y) {
long long v = 1;
while (y > 0) {
if (y & 1) v = v * x;
y = y >> 1;
x = x * x;
}
return v;
}
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
long long ceil(long long a, long long b) { return (a + b - 1) / b; }
bool areSame(vector<long long>& a, int n) {
unordered_map<int, int> m;
for (int i = 0; i < n; i++) m[a[i]]++;
if (m.size() == 1)
return true;
else
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
long long test = 1;
cin >> test;
while (test--) {
long long n;
cin >> n;
vector<int> a(n);
map<int, int> mp;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
vector<long long> vals;
for (auto i : mp) {
vals.push_back(i.second);
}
sort(vals.begin(), vals.end());
reverse(vals.begin(), vals.end());
long long ans = vals[0];
long long temp = vals[0];
for (int i = 1; i < vals.size(); i++) {
temp = min(temp - 1, vals[i]);
if (temp >= 0) ans += temp;
}
cout << ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
using item = pair<int, ii>;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int i, n, m;
cin >> n >> m;
vector<int> x(n);
vector<int> rest;
queue<item> dist;
for (i = 0; i < n; i++) cin >> x[i];
sort(x.begin(), x.end());
dist.push({1, {INT_MIN, 0}});
dist.push({1, {INT_MAX, n - 1}});
for (i = 0; i < n - 1; i++) {
if (x[i + 1] - x[i] >= 2) dist.push({1, {i, i + 1}});
}
i = 0;
int a, b, valor;
long long sum = 0;
auto ini = dist.front();
while (i != m) {
ini = dist.front();
a = (ini.second).first;
b = (ini.second).second;
valor = ini.first;
sum += valor;
if (a == INT_MAX)
rest.push_back(x[b] + valor);
else
rest.push_back(x[b] - valor);
i++;
dist.pop();
if (i != m) {
if (a != INT_MIN && a != INT_MAX) {
if (x[b] - x[a] > 2 * valor) {
i++;
sum += valor;
rest.push_back(x[a] + valor);
if (x[b] - x[a] > 2 * valor + 1) dist.push({valor + 1, {a, b}});
}
} else {
dist.push({valor + 1, {a, b}});
}
}
}
cout << sum << endl;
for (i = 0; i < rest.size(); i++) cout << rest[i] << ' ';
cout << endl;
return 0;
}
| 10 |
//#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <set>
#include <bitset>
#include <queue>
#include <tuple>
#include <map>
#include <random>
#include <chrono>
using namespace std;
#define fastInp cin.tie(0); cout.tie(0);
#define sqrt sqrtl
#define pb push_back
typedef long long ll;
typedef long double ld;
const ll SZ = 1e5 + 100, INF = 1e9 + 100, K = 53;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<vector<pair<ll, ll>>> gr;
ll n, m;
ll dist[SZ];
ll d2[SZ][53];
struct vrt {
ll type, v, c;
};
set<tuple<ll, ll, ll, ll>> s;
void djikstra() {
s.insert({ 0, 0, 0, 0 });
for (int i = 1; i < n; i++) {
dist[i] = INF;
s.insert({ dist[i], 0, i, 0 });
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < K; j++) {
d2[i][j] = INF;
vrt a = { 1, i, j };
s.insert({ d2[i][j], 1, i, j });
}
}
while (!s.empty()) {
ll d = get<0>(*s.begin());
vrt v = { get<1>(*s.begin()), get<2>(*s.begin()), get<3>(*s.begin()) };
s.erase(s.begin());
if (d >= INF) continue;
if (v.type == 0) {
for (auto to : gr[v.v]) {
if (d2[to.first][to.second] > d) {
tuple<ll, ll, ll, ll> u = { d2[to.first][to.second], 1, to.first, to.second };
s.erase(u);
d2[to.first][to.second] = d;
u = { d2[to.first][to.second], 1, to.first, to.second };
s.insert(u);
}
}
}
else {
for (auto to : gr[v.v]) {
ll cost = (to.second + v.c) * (to.second + v.c);
if (dist[to.first] > d + cost) {
tuple<ll, ll, ll, ll> u = { dist[to.first], 0, to.first, 0 };
s.erase(u);
dist[to.first] = d + cost;
u = { dist[to.first], 0, to.first, 0 };
s.insert(u);
}
}
}
}
}
int main() {
fastInp;
cin >> n >> m;
gr.resize(n);
for (int i = 0; i < m; i++) {
ll u, v, c;
cin >> u >> v >> c;
u--; v--;
gr[u].push_back({ v, c });
gr[v].push_back({ u, c });
}
djikstra();
for (int i = 0; i < n; i++) {
if (dist[i] < INF) {
cout << dist[i] << " ";
}
else {
cout << "-1 ";
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
a = abs(a), b = abs(b);
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long fast_pow(long long x, long long exp, long long mod) {
long long ret = 1;
while (exp) {
if (exp & 1) ret = (ret * x) % mod;
x = (x * x) % mod;
exp >>= 1;
}
return ret;
}
const int dx[] = {0, 0, -1, 1};
const int dy[] = {-1, 1, 0, 0};
const int inf = (int)1e9 + 5;
vector<vector<int> > adj;
vector<int> v;
priority_queue<int> q;
map<int, int> mp;
set<int> st;
int n, dp[1000000 + 5];
bool vis[1000000 + 5];
int dfs(int cur) {
vis[cur] = true;
dp[cur] = 1;
for (auto next : adj[cur]) {
if (vis[next] == false) {
dp[cur] += dfs(next);
}
}
return dp[cur];
}
int32_t main(void) {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
cin >> n;
adj.resize(n + 1);
int u, v;
for (int i = 0; i < n - 1; ++i) {
cin >> u >> v;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
if (n & 1) {
cout << -1;
return 0;
}
dfs(1);
int res = 0;
for (int i = 2; i < n + 1; ++i) res += (dp[i] % 2 == 0);
cout << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a, b;
cin >> n;
int c = 0;
while (n--) {
cin >> a >> b;
if (b - a >= 2) ++c;
}
cout << c << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, a, b, c, t, ans = 0;
cin >> t;
while (t--) {
ans = 0;
cin >> a >> b >> k;
c = k / 2;
k -= c;
ans += k * a;
ans -= c * b;
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool chmin(int &x, int y) { return y < x ? x = y, true : false; }
const int maxN = 500 + 5;
const int maxK = 10 + 2;
int n, k;
int a[maxN], ch[maxN][maxK], f[maxN][maxN][maxK], cnt = 1;
int g[maxN][maxK];
void dp(int u, int dep) {
for (int c = 0; c < 10; ++c)
if (ch[u][c]) dp(ch[u][c], dep + 1);
memset(f[u], 0, sizeof(f[u]));
for (int c = 0; c < 10; ++c)
if (ch[u][c]) {
int v = ch[u][c];
memcpy(g, f[u], sizeof(f[u]));
memset(f[u], 0x3f, sizeof(f[u]));
for (int d = 0; d <= dep; ++d)
for (int i = 0; i <= k; ++i)
for (int j = 0; j + i <= k; ++j)
chmin(f[u][d][i + j], g[d][i] + f[v][d][j]);
}
for (int d = 0; d <= dep; ++d)
for (int i = 0; i <= k; ++i)
if (f[u][d][i] < 0x3f3f3f3f) f[u][d][i] += (dep - d) * a[u];
if (dep > 0)
for (int d = 0; d <= dep - 1; ++d)
for (int i = 0; i <= k - 1; ++i) chmin(f[u][d][i + 1], f[u][dep][i]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
memset(ch, 0, sizeof(ch));
memset(a, 0, sizeof(a));
for (int i = 0; i < n; ++i) {
string s;
int m;
cin >> s >> m;
int u = 1;
for (int i = 0; i < (int)s.size(); ++i) {
int c = s[i] - '0';
if (ch[u][c] == 0) ch[u][c] = ++cnt;
u = ch[u][c];
}
a[u] += m;
}
dp(1, 0);
int ans = 0x3f3f3f3f;
for (int i = 0; i <= k; ++i) chmin(ans, f[1][0][i]);
cout << ans << endl;
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int arr[100001];
int ans[100001];
void si() {
arr[1] = 1;
for (int z = 2; z < 100001; z++)
if (!arr[z])
for (int j = z; j < 100001; j += z) arr[j] = (!arr[j] ? z : arr[j]);
}
char c;
int x, tmp;
bool k;
void act() {
if (x == 1) {
if (ans[x]) {
k = 0;
return;
}
ans[x] = 1;
return;
}
while (tmp != 1) {
if (ans[tmp]) {
k = 0;
tmp = ans[tmp];
return;
}
if (ans[arr[tmp]]) {
k = 0;
tmp = ans[arr[tmp]];
return;
}
tmp /= arr[tmp];
}
tmp = x;
while (tmp != 1) {
ans[tmp] = x;
ans[arr[tmp]] = x;
tmp /= arr[tmp];
}
}
void dec() {
if (x == 1) ans[x] = 0;
while (tmp != 1) {
ans[tmp] = 0;
ans[arr[tmp]] = 0;
tmp /= arr[tmp];
}
}
void sol() {
cin >> c >> x;
k = 1;
tmp = x;
if (c == '-') {
if (ans[x] == x) {
printf("Success\n");
dec();
} else
printf("Already off\n");
} else {
if (ans[x] == x)
printf("Already on\n");
else {
act();
if (k)
printf("Success\n");
else
printf("Conflict with %d\n", tmp);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
si();
int n, m;
cin >> n >> m;
while (m--) sol();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 300000;
int a[MAX + 10];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
int l = 0, r = m;
while (l < r) {
int mid = (l + r) >> 1;
int minn = 0;
bool f = true;
for (int i = 1; i <= n; ++i) {
if (a[i] <= minn) {
if (a[i] + mid < minn) {
f = false;
break;
}
} else {
if (a[i] + mid < minn + m) {
minn = a[i];
}
}
}
if (f)
r = mid;
else
l = mid + 1;
}
printf("%d\n", l);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int a = 0;
bool o = false;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '1') o = true;
if (o && s[i] == '0') ++a;
}
cout << (a >= 6 ? "yes" : "no") << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; }
int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; }
const long long int MAXN = 1e5 + 10;
const long long int LOG_A = 21;
struct basis {
long long int basis_v[LOG_A];
long long int sz;
basis() {
for (long long int i = (0); i <= (LOG_A - 1); ++i) basis_v[i] = 0;
sz = 0;
}
void insertVector(long long int mask) {
for (long long int i = LOG_A - 1; i >= 0; i--) {
if ((mask & (1LL << i)) == 0) continue;
if (!basis_v[i]) {
basis_v[i] = mask;
++sz;
return;
}
mask ^= basis_v[i];
}
}
bool can(long long int x) {
for (long long int i = LOG_A - 1; i >= 0; i--) {
x = min(x, (x ^ basis_v[i]));
}
return (x == 0);
}
};
const long long int MOD = 1e9 + 7;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y) {
if (y & 1) res = (res * x) % MOD;
x = (x * x) % MOD;
y >>= 1;
}
return res;
}
basis arr[MAXN];
void solve() {
long long int n, q;
cin >> n >> q;
for (long long int i = (1); i <= (n); ++i) {
long long int x;
cin >> x;
arr[i] = arr[i - 1];
arr[i].insertVector(x);
}
while (q--) {
long long int l, x;
cin >> l >> x;
if (arr[l].can(x) == 0)
cout << 0 << '\n';
else
cout << power(2, l - arr[l].sz) << '\n';
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
t = 1;
for (long long int i = (1); i <= (t); ++i) {
solve();
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5 + 3;
vector<pair<int, int> > g;
int ans[mxn * 2], n;
map<int, int> mat;
int main() {
scanf("%d", &n);
for (int(i) = (int)(0); (i) < (int)(n); ++(i)) {
int u, v;
scanf("%d%d", &u, &v);
g.push_back(make_pair(u, v));
mat[u] = v;
mat[v] = u;
}
for (int(i) = (int)(1); (i) <= (int)(2 * n); ++(i))
if (!ans[i]) {
int cur = i;
while (ans[cur] == 0) {
ans[cur] = 1;
int nxt;
if (cur & 1)
nxt = cur + 1;
else
nxt = cur - 1;
if (ans[nxt] == 0) {
ans[nxt] = 2;
cur = mat[nxt];
}
}
}
for (int(i) = (int)(0); (i) < (int)(n); ++(i))
printf("%d %d\n", ans[g[i].first], ans[g[i].second]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
int min(int a, int b) {
if (a < b) return a;
return b;
}
int dist[60][60];
int MAX[100];
int MIN[100];
long long f[60][60];
int a;
int main() {
int n, m;
scanf("%d%d", &n, &m);
memset(dist, 50, sizeof(dist));
for (int i = 0; i < m; i++) {
int v, u, c;
scanf("%d%d%d", &v, &u, &c);
dist[v - 1][u - 1] = c;
dist[u - 1][v - 1] = c;
dist[v - 1][v - 1] = 0;
dist[u - 1][u - 1] = 0;
}
int g1, g2, s1, s2;
scanf("%d%d%d%d", &g1, &g2, &s1, &s2);
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) dist[i][j] = dist[i][j] * 100 + i;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = j + 1; k < n; k++)
if (dist[i][j] > dist[i][k]) {
int t = dist[i][j];
dist[i][j] = dist[i][k];
dist[i][k] = t;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n - 1; j++) dist[i][j] = dist[i][j + 1];
for (int i = 0; i < n; i++) {
MAX[i] = dist[i][n - 1];
MIN[i] = dist[i][0];
}
long long rez = 0;
int g[60], b[60], s[60];
for (int A = 0; A < n; A++)
for (int B = 0; B < n; B++)
if (A != B && MIN[A] < MAX[B]) {
for (int i = 0; i < n; i++) g[i] = b[i] = s[i] = 0;
for (int i = 0; i < n; i++)
if (MIN[i] < MIN[A]) g[i] = 1;
for (int i = 0; i < n; i++)
if (MAX[i] > MAX[B]) b[i] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n - 1; j++)
if (dist[i][j] > MIN[A] && dist[i][j] < MAX[B]) s[i] = 1;
g[A] = 1;
b[A] = s[A] = 0;
g[B] = 0;
s[B] = 0;
b[B] = 1;
memset(f, 0, sizeof(f));
f[0][0] = 1;
for (int k = 0; k < n; k++)
for (int i = n; i >= 0; i--)
for (int j = n; j >= 0; j--) {
if (g[k]) f[i + 1][j] += f[i][j];
if (s[k]) f[i][j + 1] += f[i][j];
if (!b[k]) f[i][j] = 0;
}
for (int i = g1; i <= g2; i++)
for (int j = s1; j <= s2; j++) rez += f[i][j];
}
printf("%lld", rez);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1E9 + 9;
long long process(string &str, int x, int y) {
if (x > y) return 0;
stringstream ss;
ss << str;
long long ret = 0;
stack<long long> st;
char ch;
while (ss >> ch) {
if (ch == '+') {
long long d;
ss >> d;
st.push(d);
} else if (ch == '*') {
long long d;
ss >> d;
d = d * st.top();
st.pop();
st.push(d);
} else {
ss.unget();
long long d;
ss >> d;
st.push(d);
}
}
ret = st.top();
st.pop();
while (!st.empty()) {
ret = ret + st.top();
st.pop();
}
return ret;
}
string pro(long long x) {
string ret;
while (x) {
ret.push_back(x % 10 + '0');
x /= 10;
}
int len = ret.size();
for (int i = 0, j = len - 1; i < len / 2; i++, j--) swap(ret[i], ret[j]);
return ret;
}
pair<int, int> interval[20];
int main() {
string str;
cin >> str;
str.push_back('*');
int p = -1, cnt = 0;
for (int i = 0; i < str.size(); i++) {
if (str[i] == '*') {
interval[cnt++] = make_pair(p + 1, i - 1);
p = i;
}
}
str.erase(--str.end());
long long Max = process(str, 0, str.size() - 1);
for (int i = 0; i < cnt; i++) {
for (int j = i; j < cnt; j++) {
int x = interval[i].first;
int y = interval[j].second;
string cal = str.substr(x, y - x + 1);
long long temp = process(cal, 0, cal.size() - 1);
static string s;
s.clear();
cal.clear();
if (x == 0) {
if (y == str.size() - 1) {
} else {
s = pro(temp) + str.substr(y + 1);
temp = process(s, 0, s.size() - 1);
}
} else {
if (y == str.size() - 1) {
s = str.substr(0, x) + pro(temp);
temp = process(s, 0, s.size() - 1);
} else {
s = str.substr(0, x) + pro(temp) + str.substr(y + 1);
temp = process(s, 0, s.size() - 1);
}
}
Max = max(Max, temp);
}
}
cout << Max;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
n = 180 - n;
if (360 % n == 0)
cout << "YES";
else
cout << "NO";
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
const long double EPS = 1e-9;
const long double PI = 3.1415926535897932384626434;
using namespace std;
int n, m;
int a[15], b[15];
int x[15], y[15];
set<int> v1[100][100];
set<int> v2[100][100];
set<int> pos1, pos2;
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
if (a[i] > b[i]) swap(a[i], b[i]);
}
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
if (x[i] > y[i]) swap(x[i], y[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (x[j] == a[i] && y[j] == b[i]) continue;
if (x[j] == a[i] || x[j] == b[i]) {
v1[a[i]][b[i]].insert(x[j]);
pos1.insert(x[j]);
}
if (y[j] == a[i] || y[j] == b[i]) {
v1[a[i]][b[i]].insert(y[j]);
pos1.insert(y[j]);
}
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (a[j] == x[i] && b[j] == y[i]) continue;
if (a[j] == x[i] || a[j] == y[i]) {
v2[x[i]][y[i]].insert(a[j]);
pos2.insert(a[j]);
}
if (b[j] == x[i] || b[j] == y[i]) {
v2[x[i]][y[i]].insert(b[j]);
pos2.insert(b[j]);
}
}
}
if (pos1.size() == 1 && pos2.size() == 1) {
cout << *pos1.begin();
return 0;
}
bool flag1 = false, flag2 = false;
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= 9; j++) {
if (v1[i][j].size() > 1 || v2[i][j].size() > 1) {
cout << "-1";
return 0;
}
if (v1[i][j].size() == 1) flag1 = true;
if (v2[i][j].size() == 1) flag2 = true;
}
}
if (flag1 && flag2)
cout << "0";
else
cout << "-1";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
int read() {
int x = 0, f = 1;
char ch;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
return x * f;
}
const int MaxN = 2001234, P = 1e9 + 7;
int n;
char s[MaxN];
namespace PAM {
char s[MaxN];
int ch[MaxN][26], fail[MaxN], len[MaxN], par[MaxN], dif[MaxN], lst, cnt;
void extend(int i) {
int p = lst, c = s[i] - 'a';
while (s[i - len[p] - 1] != s[i]) p = fail[p];
if (!ch[p][c]) {
int np = ++cnt, q = fail[p];
len[np] = len[p] + 2;
while (s[i - len[q] - 1] != s[i]) q = fail[q];
fail[np] = ch[q][c];
ch[p][c] = np;
dif[np] = len[np] - len[fail[np]];
if (dif[np] == dif[fail[np]])
par[np] = par[fail[np]];
else
par[np] = fail[np];
}
lst = ch[p][c];
}
void init() {
cnt = fail[0] = 1;
len[1] = -1;
len[0] = 0;
}
int f[MaxN], g[MaxN];
int dp() {
f[0] = 1;
for (int i = 1; i <= n; i++) {
extend(i);
for (int p = lst; p; p = par[p]) {
g[p] = f[i - len[par[p]] - dif[p]];
if (dif[p] == dif[fail[p]]) (g[p] += g[fail[p]]) %= P;
(f[i] += g[p]) %= P;
}
if (i & 1) f[i] = 0;
}
return f[n];
}
} // namespace PAM
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i * 2 <= n; i++) {
PAM ::s[i * 2 - 1] = s[i];
PAM ::s[i * 2] = s[n - i + 1];
}
PAM ::init();
cout << PAM ::dp();
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, m, sx, sy;
int main() {
cin >> n >> m >> sx >> sy;
int cnt = 0;
for (int i = sx; i < n + 1; ++i) {
if (i == sx) {
for (int j = sy; j <= m; ++j) {
cout << i << " " << j << endl;
}
for (int j = sy - 1; j > 0; --j) {
cout << i << " " << j << endl;
}
continue;
}
if (cnt % 2 == 0) {
for (int j = 1; j <= m; ++j) {
cout << i << " " << j << endl;
}
} else
for (int j = m; j > 0; --j) {
cout << i << " " << j << endl;
}
cnt++;
}
for (int i = sx - 1; i > 0; --i) {
if (cnt % 2 == 0)
for (int j = 1; j <= m; ++j) {
cout << i << " " << j << endl;
}
else
for (int j = m; j > 0; --j) {
cout << i << " " << j << endl;
}
cnt++;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
float glass[11][11];
int n, t;
int ans = 0;
int main() {
cin >> n >> t;
glass[0][0] = t;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
if (glass[i][j] >= 1) {
float out = (glass[i][j] - 1) / 2;
glass[i + 1][j] += out;
glass[i + 1][j + 1] += out;
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, l, r;
cin >> n >> l >> r;
long long b = 0;
long long a = 0;
for (int i = 0; i < l; i++) {
a += pow(2, i);
}
std::cout << std::setprecision(20) << (n - l) + a << " ";
for (int i = 0; i < r; i++) {
b += pow(2, i);
}
std::cout << std::setprecision(20) << b + (n - r) * pow(2, r - 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long t;
if (a > b) {
t = a;
a = b;
b = t;
}
while (a % b != 0) {
t = b;
b = a % b;
a = t;
}
return b;
}
long long a[200020];
int n;
int main() {
scanf("%d", &n);
long long cd;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
if (i == 1)
cd = a[1];
else
cd = gcd(cd, a[i]);
}
if (cd > 1) {
printf("YES\n0");
return 0;
}
bool flag = true;
int count = 0;
while (flag) {
flag = false;
for (int i = 1; i < n; i++) {
if (a[i] & 1) {
flag = true;
count++;
a[i] -= a[i + 1];
a[i + 1] = a[i + 1] * 2 + a[i];
i++;
}
}
}
if (a[n] & 1) count += 2;
printf("YES\n%d", count);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, R, f[51], s[51], p[51];
double dp[52][5002], low = 1, high = 10000000000000000;
int main() {
cout << fixed << setprecision(16);
cin >> N >> R;
for (int i = 1; i <= N; ++i) {
cin >> f[i] >> s[i] >> p[i];
}
for (int i = 0; i < 80; ++i) {
double mid = (low + high) / 2;
for (int i = N; i > 0; --i) {
for (int j = 0; j <= R; ++j) {
if (j + f[i] <= R) {
dp[i][j] +=
(double)p[i] * (min(dp[i + 1][j + f[i]], mid) + f[i]) / 100;
} else {
dp[i][j] += (double)p[i] * (mid + f[i]) / 100;
}
if (j + s[i] <= R) {
dp[i][j] +=
(1 - (double)p[i] / 100) * (min(dp[i + 1][j + s[i]], mid) + s[i]);
} else {
dp[i][j] += (1 - (double)p[i] / 100) * (mid + s[i]);
}
}
}
if (dp[1][0] > mid) {
low = mid;
} else {
high = mid;
}
for (int i = 0; i <= N; ++i) {
for (int j = 0; j <= R; ++j) {
dp[i][j] = 0;
}
}
}
cout << (low + high) / 2 << '\n';
}
| 16 |
#include <bits/stdc++.h>
int n, max_num;
int qcnt;
bool chk[1000010];
int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
int main() {
srand(time(NULL));
int ret;
scanf("%d", &n);
if (n <= 60) {
int min_num = 1000000000;
for (int i = 1; i <= n; ++i) {
printf("? %d\n", i);
fflush(stdout);
scanf("%d", &ret);
if (ret > max_num) max_num = ret;
if (ret < min_num) min_num = ret;
}
printf("! %d %d\n", min_num, (max_num - min_num) / (n - 1));
fflush(stdout);
return 0;
}
int l = 0, r = 999999999, mid;
while (l <= r) {
mid = (l + r) / 2;
printf("> %d\n", mid);
fflush(stdout);
scanf("%d", &ret);
++qcnt;
if (ret == 1) {
max_num = mid + 1;
l = mid + 1;
} else {
r = mid - 1;
}
}
int d = 0;
for (; qcnt < 60;) {
int tmp = (rand() * rand()) % n + 1;
while (chk[tmp]) tmp = (rand() * rand()) % n + 1;
chk[tmp] = true;
printf("? %d\n", tmp);
fflush(stdout);
scanf("%d", &ret);
++qcnt;
d = gcd(d, max_num - ret);
}
printf("! %d %d\n", max_num - d * (n - 1), d);
fflush(stdout);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
struct punct {
long long int x, y;
punct(long long int x = 0, long long int y = 0) : x(x), y(y) {}
};
struct punct2 {
punct a[4];
} v[4][105];
long long int dist(const punct &a, const punct &b) {
return ((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool drept(const punct &a, const punct &b, const punct &c) {
return (dist(a, b) + dist(b, c) == dist(a, c));
}
punct spec;
bool operator<(const punct &a, const punct &b) {
return dist(a, spec) < dist(b, spec);
}
bool patrat(punct a, punct b, punct c, punct d) {
vector<punct> v;
spec = a;
v.push_back(a);
v.push_back(b);
v.push_back(c);
v.push_back(d);
sort(v.begin(), v.end());
if (!dist(spec, v[3])) return false;
return (dist(v[0], v[1]) == dist(v[1], v[3]) &&
dist(v[0], v[1]) == dist(v[0], v[2]) &&
dist(v[0], v[1]) == dist(v[2], v[3]) && drept(v[1], v[0], v[2]));
}
signed main() {
long long int n = 0;
cin >> n;
long long int a, b, k;
for (long long int i = 1; i <= n; i++)
for (k = 0; k < 4; k++) {
cin >> v[k][i].a[0].x >> v[k][i].a[0].y;
cin >> a >> b;
v[k][i].a[1].x = a + b - v[k][i].a[0].y;
v[k][i].a[1].y = -a + b + v[k][i].a[0].x;
v[k][i].a[2].x = 2 * a - v[k][i].a[0].x;
v[k][i].a[2].y = 2 * b - v[k][i].a[0].y;
v[k][i].a[3].x = a - b + v[k][i].a[0].y;
v[k][i].a[3].y = a + b - v[k][i].a[0].x;
}
long long int j, minim;
long long int l, p;
for (long long int i = 1; i <= n; i++) {
minim = 30;
for (j = 0; j < 4; j++)
for (k = 0; k < 4; k++)
for (l = 0; l < 4; l++)
for (p = 0; p < 4; p++)
if (patrat(v[0][i].a[j], v[1][i].a[k], v[2][i].a[l], v[3][i].a[p]))
if (j + k + l + p < minim) minim = j + k + l + p;
if (minim == 30)
cout << "-1\n";
else
cout << minim << '\n';
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long P[2000005], flag[2000005];
long long cntP[2000005], cntQ[2000005];
bool isPalin(long long num) {
string st = "";
while (num > 0) {
long long temp = num % 10;
st = st + char(temp + 48);
num = num / 10;
}
int N = st.length();
int i = N / 2;
while (i >= 0) {
if (st[i] != st[(N - i - 1)]) return false;
i--;
}
return true;
}
int main() {
long long LMT = sqrtl(2000005);
for (int i = 3; i <= LMT; i++) {
if (!flag[i]) {
for (int j = i * i, k = i << 1LL; j < 2000005; j += k) flag[j] = 1;
}
}
P[0] = 2;
int j = 1;
for (int i = 3; i < 2000005; i += 2)
if (!flag[i]) P[j++] = i;
int total = j;
for (int i = 0; i < total; i++) cntP[P[i]] = 1;
for (int i = 1; i < 2000005; i++) cntP[i] = cntP[i - 1] + cntP[i];
for (int i = 1; i < 2000005; i++)
if (isPalin(i)) cntQ[i] = 1;
for (int i = 1; i < 2000005; i++) cntQ[i] = cntQ[i - 1] + cntQ[i];
long long p, q;
scanf("%lld %lld", &p, &q);
for (int i = 2000005 - 1000; i >= 0; i--) {
if (cntP[i] * q <= cntQ[i] * p) {
printf("%d\n", i);
return 0;
}
}
puts("Palindromic tree is better than splay tree");
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.