solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int d[200000], i;
long int n, a;
cin >> n;
a = n / 2;
if (1 == n % 2)
d[0] = 7;
else
d[0] = 1;
cout << d[0];
for (i = 1; i < a; i++) {
d[i] = 1;
cout << d[1];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
long long max(long long a, long long b) { return (a > b) ? a : b; }
long long min(long long a, long long b) { return (a < b) ? a : b; }
void solve() {
vector<long long> v(5);
long long sum = 0;
for (long long i = 0; i < 5; i++) {
cin >> v[i];
sum += v[i];
}
sort(v.begin(), v.end());
long long best = 0;
for (long long i = 0; i < 5; i++) {
if (i + 1 < 5 && v[i] == v[i + 1]) {
best = max(best, 2 * v[i]);
}
if (i + 2 < 5 && v[i] == v[i + 2]) {
best = max(best, 3 * v[i]);
}
}
cout << sum - best << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int A, B;
inline int read() {
int ret = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch <= '9' && ch >= '0') ret = ret * 10 + ch - '0', ch = getchar();
return ret * f;
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
int x = read();
read();
if (x < 0)
A++;
else
B++;
}
if (A < 2 || B < 2)
printf("Yes");
else
printf("No");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double pai = acos(-1.0L);
const long double eps = 1e-10;
const long long mod = 1e9 + 7;
const int MXN = 1e6 + 5;
vector<int> g[MXN], v;
int co[MXN];
int go[MXN];
void dfs(int now, int pr, int cg0, int cg1, int dis) {
if (dis % 2 == 0) {
if ((co[now] + cg1) % 2 != go[now]) v.push_back(now), cg1++;
} else {
if ((co[now] + cg0) % 2 != go[now]) v.push_back(now), cg0++;
}
for (auto i : g[now]) {
if (i == pr) continue;
dfs(i, now, cg0, cg1, dis + 1);
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int sa, sb;
scanf("%d %d", &sa, &sb);
g[sa].push_back(sb);
g[sb].push_back(sa);
}
for (int i = 1; i <= n; i++) scanf("%d", &co[i]);
for (int i = 1; i <= n; i++) scanf("%d", &go[i]);
dfs(1, -1, 0, 0, 0);
cout << (int)v.size() << '\n';
for (auto i : v) cout << i << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e4 + 7;
long long expo(long long x, long long n, long long mod) {
long long res = 1LL;
while (n) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n = n / 2;
}
return res;
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int i, j;
unsigned long long n;
cin >> n;
vector<int> v;
if (n < 10) return cout << -1, 0;
string s, str;
s = to_string(n);
int h[26] = {0};
for (int i = (0); i < (int)((s).size()); i++) h[s[i] - '0']++;
if ((h[0] < 2) && (h[0] == 0 || h[5] == 0) && (h[7] == 0 || h[5] == 0) &&
(h[2] == 0 || h[5] == 0))
return cout << -1 << ' ', 0;
int c;
if (h[0] > 0 && h[5] > 0) {
str = s;
c = 0;
for (i = (int)((str).size()) - 1; i >= 0; i--)
if (str[i] == '0') break;
for (int j = (i); j < (int)((s).size()) - 1; j++)
swap(str[j], str[j + 1]), c++;
for (i = (int)((str).size()) - 2; i >= 0; i--)
if (str[i] == '5') break;
for (int j = (i); j < (int)((s).size()) - 2; j++)
swap(str[j], str[j + 1]), c++;
if (str[0] == '0') {
i = 0;
while (str[i] == '0' && i < (int)((str).size())) i++;
for (j = i; j > 0; j--) swap(str[j], str[j - 1]), c++;
}
v.push_back(c);
}
if (h[0] > 1) {
str = s;
c = 0;
for (i = (int)((str).size()) - 1; i >= 0; i--)
if (str[i] == '0') break;
for (int j = (i); j < (int)((s).size()) - 1; j++)
swap(str[j], str[j + 1]), c++;
for (i = (int)((str).size()) - 2; i >= 0; i--)
if (str[i] == '0') break;
for (int j = (i); j < (int)((s).size()) - 2; j++)
swap(str[j], str[j + 1]), c++;
if (str[0] == '0') {
i = 0;
while (str[i] == '0' && i < (int)((str).size())) i++;
for (j = i; j > 0; j--) swap(str[j], str[j - 1]), c++;
}
v.push_back(c);
}
if (h[5] > 0 && h[7] > 0) {
str = s;
c = 0;
for (i = (int)((str).size()) - 1; i >= 0; i--)
if (str[i] == '5') break;
for (int j = (i); j < (int)((s).size()) - 1; j++)
swap(str[j], str[j + 1]), c++;
for (i = (int)((str).size()) - 2; i >= 0; i--)
if (str[i] == '7') break;
for (int j = (i); j < (int)((s).size()) - 2; j++)
swap(str[j], str[j + 1]), c++;
if (str[0] == '0') {
i = 0;
while (str[i] == '0' && i < (int)((str).size())) i++;
for (j = i; j > 0; j--) swap(str[j], str[j - 1]), c++;
}
v.push_back(c);
}
if (h[2] > 0 && h[5] > 0) {
str = s;
c = 0;
for (i = (int)((str).size()) - 1; i >= 0; i--)
if (str[i] == '5') break;
for (int j = (i); j < (int)((s).size()) - 1; j++)
swap(str[j], str[j + 1]), c++;
for (i = (int)((str).size()) - 2; i >= 0; i--)
if (str[i] == '2') break;
for (int j = (i); j < (int)((s).size()) - 2; j++)
swap(str[j], str[j + 1]), c++;
if (str[0] == '0') {
i = 0;
while (str[i] == '0' && i < (int)((str).size())) i++;
for (j = i; j > 0; j--) swap(str[j], str[j - 1]), c++;
}
v.push_back(c);
}
if (!v.empty()) {
sort(v.begin(), v.end());
cout << v[0];
} else
cout << 0;
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
int t[100][6];
int ans = 0;
bool remove(){
bool ret = 0;
rep(i,20)rep(j,4){
if(t[i][j] != 0 && t[i][j] == t[i][j+1] && t[i][j+1] == t[i][j+2]){
//cout << t[i][j] << " " << t[i][j+1] << endl;
for(int jj = j + 1; t[i][jj] == t[i][j]; jj++){
ans += t[i][jj];
t[i][jj] = 0;
}
ans += t[i][j];
t[i][j] = 0;
ret = 1;
}
}
return ret;
}
void fall(){
rep(tt,50)rep(i,20)rep(j,5)if(t[i][j] == 0)t[i][j] = t[i+1][j],t[i+1][j] = 0;
}
int main(){
int x;
while(cin >> x, x){
ans = 0;
rep(i,100)rep(j,6)t[i][j] = 0;
rep(i,x)rep(j,5) cin >> t[x-i-1][j];
rep(i,500){
remove();
fall();
//rep(i,x){{rep(j,5)cout << t[i][j] << " ";}cout<<endl;}cout << endl;
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s1[105][101], s2[105][105], s3[105], s4[105];
int mm[105];
void change(char s[]) {
int l = strlen(s);
for (int i = 0; i < l; i++) {
if (s[i] >= 'A' && s[i] <= 'Z') s[i] += 32;
}
}
int main() {
int i, j, t, k, n, z, flag;
char letter;
while (scanf("%d", &n) != EOF) {
memset(mm, 0, sizeof(mm));
getchar();
for (i = 0; i < n; i++) {
gets(s1[i]);
strcpy(s2[i], s1[i]);
change(s2[i]);
}
gets(s3);
strcpy(s4, s3);
change(s4);
scanf("%c", &letter);
int l = strlen(s4);
for (i = 0; i < strlen(s4); i++)
for (k = 0; k < n; k++) {
for (z = 0, flag = 1, j = i; j < i + strlen(s1[k]); j++) {
if (s4[j] != s2[k][z++]) flag = 0;
}
if (l - strlen(s1[k]) + 1 >= i && flag == 1)
for (t = i; t < i + strlen(s1[k]); t++) mm[t] = 1;
}
if (letter >= 'A' && letter <= 'Z') letter += 32;
for (int i = 0; i < l; i++)
if (mm[i]) {
if (s4[i] == letter) {
char tmp;
if (s4[i] == 'a')
tmp = 'b';
else
tmp = 'a';
if (s3[i] >= 'A' && s3[i] <= 'Z')
s3[i] = tmp - 32;
else
s3[i] = tmp;
} else if (s3[i] >= 'A' && s3[i] <= 'Z')
s3[i] = letter - 32;
else
s3[i] = letter;
}
puts(s3);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
template <typename T>
struct fenwick_tree {
int tree_n = 0;
T tree_sum = 0;
vector<T> tree;
fenwick_tree(int n = -1) {
if (n >= 0) init(n);
}
void init(int n) {
tree_n = n;
tree_sum = 0;
tree.assign(tree_n + 1, 0);
}
template <typename T_array>
void build(const T_array &initial) {
assert((int)initial.size() == tree_n);
tree_sum = 0;
for (int i = 1; i <= tree_n; i++) {
tree[i] = initial[i - 1];
tree_sum += initial[i - 1];
for (int k = (i & -i) >> 1; k > 0; k >>= 1) tree[i] += tree[i - k];
}
}
void update(int index, const T &change) {
assert(0 <= index && index < tree_n);
tree_sum += change;
for (int i = index + 1; i <= tree_n; i += i & -i) tree[i] += change;
}
T query(int count) const {
assert(count <= tree_n);
T sum = 0;
for (int i = count; i > 0; i -= i & -i) sum += tree[i];
return sum;
}
T query_suffix(int start) const { return tree_sum - query(start); }
T query(int a, int b) const { return query(b) - query(a); }
T get(int a) const {
assert(0 <= a && a < tree_n);
int above = a + 1;
T sum = tree[above];
above -= above & -above;
while (a != above) {
sum -= tree[a];
a -= a & -a;
}
return sum;
}
bool set(int index, T value) {
assert(0 <= index && index < tree_n);
T current = get(index);
if (current == value) return false;
update(index, value - current);
return true;
}
int find_last_prefix(T sum) const {
if (sum < 0) return -1;
int prefix = 0;
for (int k = 31 - __builtin_clz(tree_n); k >= 0; k--)
if (prefix + (1 << k) <= tree_n && tree[prefix + (1 << k)] <= sum) {
prefix += 1 << k;
sum -= tree[prefix];
}
return prefix;
}
};
const int ALPHABET = 26;
const char MIN_CHAR = 'a';
int N;
string S;
vector<int> eq_freq;
fenwick_tree<int> tree;
int needed() {
int maximum = 0, sum = 0;
for (int c = 0; c < ALPHABET; c++) {
maximum = max(maximum, eq_freq[c]);
sum += eq_freq[c];
}
return max(maximum, (sum + 1) / 2) + 1;
}
bool can_match(char x, char y) {
if (x == y) return false;
int before = needed();
eq_freq[x - MIN_CHAR]--;
eq_freq[y - MIN_CHAR]--;
int after = needed();
eq_freq[x - MIN_CHAR]++;
eq_freq[y - MIN_CHAR]++;
return after == before - 1;
}
void run_case() {
cin >> S;
N = S.size();
tree.init(N);
tree.build(vector<int>(N, 1));
vector<pair<int, int>> moves;
auto &&add_move = [&](int start, int end) {
int under_start = tree.query(start);
int under_end = tree.query(end);
moves.emplace_back(under_start, under_end);
while (true) {
int x = tree.find_last_prefix(under_start);
if (x >= end) break;
tree.update(x, -1);
}
};
eq_freq.assign(ALPHABET, 0);
vector<pair<int, int>> eq_vec;
for (int i = 0; i < N - 1; i++)
if (S[i] == S[i + 1]) {
eq_vec.emplace_back(i, i + 1);
eq_freq[S[i] - MIN_CHAR]++;
}
vector<pair<int, int>> eq_stack;
for (pair<int, int> &eq : eq_vec)
if (!eq_stack.empty() && can_match(S[eq_stack.back().first], S[eq.first])) {
eq_freq[S[eq_stack.back().first] - MIN_CHAR]--;
eq_freq[S[eq.first] - MIN_CHAR]--;
add_move(eq_stack.back().second, eq.first + 1);
eq_stack.pop_back();
} else {
eq_stack.push_back(eq);
}
while (!eq_stack.empty()) {
add_move(eq_stack.back().second, N);
eq_stack.pop_back();
}
add_move(0, N);
cout << moves.size() << '\n';
for (pair<int, int> &move : moves)
cout << move.first + 1 << ' ' << move.second << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int tests;
cin >> tests;
while (tests-- > 0) run_case();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
ifstream file("input.txt");
int main() {
int n, m = 0;
string str;
cin >> n >> str;
for (int i = 0; i < n; i++) {
if (str[i] == '<')
m++;
else
break;
}
for (int i = n - 1; i >= 0; i--) {
if (str[i] == '>')
m++;
else
break;
}
cout << m;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, l, p;
cin >> n >> m;
p = n;
int arr[m];
string s[n];
int k = 0;
for (i = 0; i < m; i++) {
arr[i] = 0;
}
while (p-- > 0) {
cin >> s[k];
for (i = 0; i < m; i++) {
arr[i] = arr[i] + (s[k][i] % 48);
}
k++;
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
arr[j] -= (s[i][j] % 48);
}
for (l = 0; l < m; l++) {
if (arr[l] == 0) break;
}
if (l == m) {
cout << "YES" << endl;
return 0;
}
for (j = 0; j < m; j++) {
arr[j] += (s[i][j] % 48);
}
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000005;
const long long INFLL = 1000000000000000002ll;
const long long MOD = 1000000007;
inline long long min(long long a, long long b, long long c) {
return min(min(a, b), c);
}
inline long long min(long long a, long long b, long long c, long long d) {
return min(min(min(a, b), c), d);
}
inline long long max(long long a, long long b, long long c) {
return max(max(a, b), c);
}
inline long long max(long long a, long long b, long long c, long long d) {
return max(max(max(a, b), c), d);
}
int A[300005], DP[300005][20], Last[20], N, Q;
int main() {
cin >> N >> Q;
for (int i = (1); i <= (N); i++) cin >> A[i];
for (int b = (0); b <= (18); b++) Last[b] = INF;
for (int i = (N); i >= (1); i--) {
for (int b = (0); b <= (18); b++) DP[i][b] = INF;
for (int b = (0); b <= (18); b++)
for (int b2 = (0); b2 <= (18); b2++)
if (A[i] & (1 << b2) && Last[b2] < INF)
DP[i][b] = min(DP[i][b], DP[Last[b2]][b]);
for (int b = (0); b <= (18); b++)
if (A[i] & (1 << b)) {
Last[b] = i;
DP[i][b] = Last[b];
}
}
while (Q--) {
int x, y;
cin >> x >> y;
bool found = false;
for (int b = (0); b <= (18); b++)
if ((A[y] & (1 << b)) && DP[x][b] <= y) found = true;
if (found)
cout << "Shi\n";
else
cout << "Fou\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') positive = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
int N, M, a[405][405];
int f[405][405], tmp[405][405];
unsigned short g[405][160005];
int main() {
N = read(), M = read();
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) a[i][j] = read();
int ans = 0;
for (int i = 1; i <= N; ++i) {
for (int l = M; l; --l)
for (int r = l; r <= M; ++r) {
if (l == r)
tmp[l][r] = g[l][a[i][l]];
else {
tmp[l][r] = max(tmp[l][r - 1], tmp[l + 1][r]);
tmp[l][r] = max(tmp[l][r], (int)g[r][a[i][l]]);
tmp[l][r] = max(tmp[l][r], (int)g[l][a[i][r]]);
if (a[i][l] == a[i][r]) tmp[l][r] = i;
}
f[l][r] = max(f[l][r], tmp[l][r]);
ans = max(ans, (r - l + 1) * (i - f[l][r]));
}
for (int j = 1; j <= M; ++j) g[j][a[i][j]] = i;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MAXN = 150005;
const int INF = 1500000;
using namespace std;
int n, a[MAXN];
vector<int> v;
bool yes[MAXN];
int scan() {
int t = 0, m = 1;
char c;
c = getchar();
while ((c < '0' || c > '9') and c != '-') c = getchar();
if (c == '-') c = getchar(), m = -1;
while (c >= '0' && c <= '9') t = (t << 3) + (t << 1) + c - '0', c = getchar();
return (t * m);
}
bool judge(int x) {
if (x < 1 || x == n) return true;
if (x % 2 == 0 && a[x] > a[x + 1]) return true;
if (x % 2 == 1 && a[x] < a[x + 1]) return true;
return false;
}
int main() {
n = scan();
for (int i = 1; i <= n; i++) a[i] = scan();
for (int i = 1; i <= n; i++) {
if (!judge(i)) yes[i] = yes[i + 1] = true;
}
for (int i = 1; i <= n; i++)
if (yes[i]) v.push_back(i);
if (v.size() > 6) {
cout << 0;
return 0;
}
long long res = 0;
for (int i = 1; i <= n; i++)
if (yes[i])
for (int j = 1; j <= n; j++) {
if (j > i || !yes[j]) {
swap(a[i], a[j]);
if (judge(i - 1) && judge(i) && judge(j - 1) && judge(j)) {
for (int k = 0; k < v.size(); k++)
if (!judge(v[k])) goto stop;
res++;
}
stop:
swap(a[i], a[j]);
}
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
using namespace std;
long long int t, n, u, x, y;
const long long int N = 100001;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
t = 1;
cin >> t;
while (t--) {
cin >> n;
long long int ans = -1;
if (n % 2 == 0) {
cout << n / 2 << " " << n / 2 << endl;
continue;
}
for (long long int i = 2; i <= sqrt(n); ++i) {
if (n % i == 0) {
ans = n / i;
break;
}
}
if (ans == -1)
cout << n - 1 << " " << 1 << endl;
else
cout << ans << " " << n - ans << endl;
}
}
| 2 |
// #pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops")
#include<bits/stdc++.h>
using namespace std;
#define crap ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
typedef long long int ll;
typedef unsigned long long ull;
#define int ll
typedef std::vector<int> vi;
typedef std::vector<ll> vll;
typedef std::vector<vi > vvi;
typedef std::vector<vll > vvll;
typedef std::pair<int,int> ii;
typedef std::pair<int, ii > iii;
typedef std::pair< ll, ll > lp;
typedef std::vector<ii> vii;
typedef std::vector<vii > vvii;
#define pb push_back
#define PB pop_back
#define pf push_front
#define PF pop_front
#define mp make_pair
#define ub(a,b) upper_bound(all(a),b)
#define lb(a,b) lower_bound(all(a),b)
#define bs(a,b) binary_search(all(a),b)
#define mem(a,b) memset(a,b,sizeof(a))
#define in(a,n) F(i,0,n-1)cin>>a[i]
#define in1(a,n) F(i,1,n)cin>>a[i]
#define out(a,n) F(i,0,n-1)cout<<a[i]<<" ";cout<<endl
#define ff first
#define ss second
#define F(i,a,b) for (ll i=a;i<=b;i++)
#define RF(i,a,b) for(ll i=a;i>=b;i--)
#define rep(i,n) F(i,0,n-1)
#define clr(a) (a).clear()
#define rz resize
#define sqr(a) ((a) * (a))
#define sz(a) int((a).size())
#define len(a) int((a).length())
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin() ,(a).rend()
#define endl '\n'
#define flush cout.flush()
int mod;
// #define mod (int)1e9+123
// #define mod LLONG_MAX
// #define mod 998244353
// ################################## Debugging statements ##################################
string to_string(string s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
template <typename A, typename B>
string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
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;}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {cerr << " " << to_string(H);debug_out(T...);}
#define TRACE // comment this out for submission
#ifdef TRACE
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
// ###########################################################################################
inline int add(int a, int b){a += b; if(a >= mod)a -= mod; return a;}
inline int sub(int a, int b){a -= b; if(a < 0)a += mod; return a;}
inline int mul(int a, int b){return (int)((long long) a * b %mod);}
inline int poww(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = mul(res, a); a = mul(a, a);b /= 2;} return res;}
inline int inv(int a){return poww(a, mod - 2);}
int gcd(int a, int b, int &x, int &y){if(a == 0){x = 0, y = 1; return b;} int x1, y1; int d = gcd(b%a, a, x1, y1); x = y1 - (b/a) * x1; y = x1; return d;}
// #################################### matrix operations ####################################
inline vvi matmul(vvi A, vvi B) {int p = A.size(), q = A[0].size();int r = B.size(), s = B[0].size();assert(q == r);vvi C(p, vi(s, 0LL));
rep(i, p){rep(j, s){rep(k, q){
// C[i][j] += A[i][k] * B[k][j];
C[i][j] = add(C[i][j], mul(A[i][k], B[k][j]));
}}}return C;}
inline vvi matpow(vvi A, int n){int p = A.size(), q = A[0].size();assert(p == q);vvi res(p, vi(p, 0));rep(i, p)res[i][i] = 1;while (n){if (n&1)res = matmul(res, A);A = matmul(A, A);n >>= 1;}return res;}
// ###########################################################################################
// #################################### Combinatorics template ###############################
struct factorial{
int N;int *fac;int *ifac; int *der; int MOD;
factorial(int n, int m = 998244353){N = n;MOD = m;fac = new int[1+N];ifac = new int[1+N];der= new int[N+1];pre_calc(); calc_derangement();}
int add(int a, int b){a += b; if(a >= MOD)a -= MOD; return a;}
int subtract(int a, int b){a -= b; if(a < 0)a += MOD; return a;}
int multiply(int a, int b){return (int)((long long) a * b %MOD);}
int binpow(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = multiply(res, a); a = multiply(a, a);b /= 2;} return res;}
int inverse(int a){return binpow(a, MOD - 2);}
void pre_calc(){fac[0] = ifac[0] = 1;for (int i = 1 ; i <= N ; i++){fac[i] = multiply(fac[i-1], i);ifac[i] = multiply(ifac[i-1], inverse(i));}}
int ncr(int n , int r){return multiply(fac[n], multiply(ifac[r], ifac[n-r]));}
void calc_derangement(){
der[1] = 0;der[2] = 1;
for (int i = 3; i <= N; i++){
der[i] = multiply(i-1, add(der[i-1], der[i-2]));
}
}
int derangement(int n){
if (n == 1) return 1;
return der[n];
}
};
vi factors_n(int n){std::vector<int> fac;for (int i = 1; i * i <= n ; i++){if (n % i == 0){fac.push_back(i);if (i * i != n){fac.push_back(n/i);}}}return fac;}
// ###########################################################################################
// ##################################### Fenwick Tree template ###############################
struct fenwick_tree{
int *bit;int n;
fenwick_tree(){this->n = 200005;this->bit = new int[200005+1]; init_bit();}
fenwick_tree(int n){this->n = n;this->bit = new int[n+1]; init_bit();}
void init_bit(){for (int i=0; i <= this->n; i++)this->bit[i]=0;}
void add(int i, int v){for (; i<=this->n; i+= i&-i){this->bit[i] = (this->bit[i] + v);}}
int get(int i){int s = 0;for (; i; i -= i&-i){s = (this->bit[i] + s);}return s;}
};
struct suffix_fenwick_tree{
int *bit;int n;
suffix_fenwick_tree(){this->n = 200005;this->bit = new int[200005+1]; init_bit();}
suffix_fenwick_tree(int n){this->n = n;this->bit = new int[n+1]; init_bit();}
void init_bit(){for (int i=0; i <= this->n; i++)this->bit[i]=0;}
void add(int i, int v){for (; i; i-= i&-i){this->bit[i] = (this->bit[i] + v);}}
int get(int i){int s = 0;for (; i <= this->n; i += i&-i){s = (this->bit[i] + s);}return s;}
};
// ###########################################################################################
// ######################################## Policy-based DS ##################################
// #include<ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
// template<class key, class value = null_type, class cmp = std::less<key>>
// using ordered_tree = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// order_of_key (val): returns the no. of values less than val
// find_by_order (k): returns the iterator to kth largest element.(0-based)
// ###########################################################################################
// ######################################## Bit manipulations ##################################
int no_of_ones(int n){return __builtin_popcount(n);}
int setmask(int mask, int i){return mask | (1 << i);}
int unsetmask(int mask, int i){return (mask & !(1 << i));}
// ###########################################################################################
// ###################################### Convex Hull Trick ##################################
// struct Line {
// mutable ll k, m, p;
// bool operator<(const Line& o) const { return k < o.k; }
// bool operator<(ll x) const { return p < x; }
// };
// struct LineContainer : multiset<Line, less<>> {
// // (for doubles, use inf = 1/.0, div(a,b) = a/b)
// const ll inf = LLONG_MAX;
// ll div(ll a, ll b) { // floored division
// return a / b - ((a ^ b) < 0 && a % b); }
// bool isect(iterator x, iterator y) {
// if (y == end()) { x->p = inf; return false; }
// if (x->k == y->k) x->p = x->m > y->m ? inf : -inf;
// else x->p = div(y->m - x->m, x->k - y->k);
// return x->p >= y->p;
// }
// void add(ll k, ll m) { // y = k * x + m
// auto z = insert({k, m, 0}), y = z++, x = y;
// while (isect(y, z)) z = erase(z);
// if (x != begin() && isect(--x, y)) isect(x, y = erase(y));
// while ((y = x) != begin() && (--x)->p >= y->p)
// isect(x, erase(y));
// }
// ll query(ll x) {
// assert(!empty());
// auto l = *lower_bound(x);
// return l.k * x + l.m;
// }
// };
// ###########################################################################################
// ######################################## Disjoint Set ##################################
// struct disjoint_sets{
// int n;
// vector<int> par;
// vector<int> ranks;
// disjoint_sets(int _n):n(_n){
// for (int i = 0; i <= n; i++){
// par.emplace_back(i);
// ranks.emplace_back(1);
// }
// }
// int find_root(int u){// path compression
// return (par[u] == u) ? u : (par[u] = find_root(par[u]));
// }
// void merge_node(int u, int v){
// u = find_root(u), v = find_root(v);
// if (u == v)
// return;
// if (ranks[u] < ranks[v])
// swap(u, v);
// par[v] = u;
// ranks[u] += ranks[v];
// }
// };
// ###########################################################################################
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
// ################################### Template ends here ####################################
void solve(){
int n;
cin >> n;
int a[1+n];
in1(a, n);
fenwick_tree ft(6+n);
F(i, 1, n){
if (a[i] == 0) continue;
int l = max(1ll, i - a[i] + 1), r = i;
ft.add(l, 1);
ft.add(r+1, -1);
}
F(i, 1, n){
int val = 0;
if (ft.get(i) > 0) val = 1;
cout << val << " \n"[i==n];
}
}
void init(){
}
void pre(){
}
signed main(){
crap;
int tt = 1;
cin >> tt;
int t0 = 1;
pre();
while (tt--){
// cout<<"Case "<< t0++ <<": ";
init();
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
long long powmod(long long a, long long b) {
long long res = 1;
a %= 1000000007;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
string s1, s2;
long long n, m, q;
long long dp[51][51];
long long t[50][3];
long long dp1[51][51][26];
long long dp2[51][51][26];
void pre() {
memset(dp1, -1, sizeof(dp1));
memset(dp2, -1, sizeof(dp2));
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n - i + 2; j++) {
long long st = j;
long long en = i + j - 1;
if (i == 1)
dp1[st][en][(s1[st - 1] - 'a')] = 1;
else {
for (int k = st; k < en; k++) {
for (int l = 0; l < q; l++) {
if (dp1[st][k][t[l][0]] == 1 && dp1[k + 1][en][t[l][1]] == 1)
dp1[st][en][t[l][2]] = 1;
}
}
}
}
}
for (int i = 1; i < m + 1; i++) {
for (int j = 1; j < m - i + 2; j++) {
long long st = j;
long long en = i + j - 1;
if (i == 1)
dp2[st][en][(s2[st - 1] - 'a')] = 1;
else {
for (int k = st; k < en; k++) {
for (int l = 0; l < q; l++) {
if (dp2[st][k][t[l][0]] == 1 && dp2[k + 1][en][t[l][1]] == 1)
dp2[st][en][t[l][2]] = 1;
}
}
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> s1 >> s2;
cin >> q;
n = ((s1).size());
m = ((s2).size());
for (int i = 0; i < q; i++) {
string temp;
cin >> temp;
t[i][0] = temp[3] - 'a';
t[i][1] = temp[4] - 'a';
t[i][2] = temp[0] - 'a';
}
pre();
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) {
for (int k = 0; k < i; k++) {
for (int l = 0; l < j; l++) {
if (dp[k][l] != -1) {
long long temp = -1;
for (int d = 0; d < 26; d++) {
if (dp1[k + 1][i][d] == 1 && dp2[l + 1][j][d] == 1) temp = 1;
}
if (temp == 1) temp += dp[k][l];
if (temp != -1 && dp[i][j] != -1)
amin(dp[i][j], temp);
else if (temp != -1 && dp[i][j] == -1)
dp[i][j] = temp;
}
}
}
}
}
cout << dp[n][m];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long t = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) t = t * 10 + c - '0', c = getchar();
return t * f;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
inline void write_p(long long x) {
write(x);
putchar(' ');
}
const long long N = 650001;
long long n, m, in[N], poi[N], nxt[N], head[N], dis[N], cnt[N], t, mx, st;
inline void add(long long x, long long y) {
poi[++t] = y;
nxt[t] = head[x];
head[x] = t;
in[x]++;
poi[++t] = x;
nxt[t] = head[y];
head[y] = t;
in[y]++;
}
inline void Bfs(long long St) {
bool ned = 0;
if (!st) ned = 1;
queue<long long> Q;
memset(dis, 0, sizeof dis);
dis[St] = 1;
Q.push(St);
while (!Q.empty()) {
long long x = Q.front();
Q.pop();
if (ned) st = x;
for (long long i = head[x]; i; i = nxt[i])
if (!dis[poi[i]]) dis[poi[i]] = dis[x] + 1, Q.push(poi[i]);
}
for (long long i = 1; i <= n; ++i) mx = max(mx, dis[i]);
}
signed main() {
n = read();
m = read();
if (n <= 10000)
if (n * (n - 1) / 2 == m) {
puts("YES");
for (long long i = 1; i <= n; ++i) write_p(1);
return 0;
}
for (long long i = 1; i <= m; ++i) add(read(), read());
Bfs(1);
if (mx == 2)
for (long long i = 1; i <= n; ++i)
if (mx == dis[i] && in[i] != in[1]) st = i;
Bfs(st);
for (long long i = 1; i <= n; ++i)
if (in[i] == in[st])
if (dis[i] == 2) dis[i] = 1;
for (long long i = 1; i <= n; ++i) cnt[dis[i]]++;
long long sum = 0;
for (long long i = 1; i <= mx; ++i) sum += cnt[i] * (cnt[i] - 1) / 2;
for (long long i = 1; i <= mx - 1; ++i) sum += cnt[i] * cnt[i + 1];
if (sum != m) {
puts("NO");
exit(0);
}
puts("YES");
for (long long i = 1; i <= n; ++i) write_p(dis[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &a) {
static char c;
int f = 0;
while (((c = getchar()) < '0' || c > '9') && (c != '-'))
;
if (c == '-') {
a = 0;
f = 1;
} else {
a = c - '0';
}
while ((c = getchar()) <= '9' && c >= '0') a = (a << 3) + (a << 1) + c - '0';
if (f) a = -a;
}
int a[100005], n, m;
char s[10005];
int main() {
int i, j, k, l, ans = 0;
scanf("%s", s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
int tag = 1;
for (k = i; k <= j; k++) {
if (s[k] != s[i + j - k]) {
tag = 0;
break;
}
}
if (!tag) ans = max(ans, j - i + 1);
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
char arr[n][m];
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
long long int count = 0;
for (long long int i = 0; i < n; i++) {
if (arr[i][m - 1] == 'R') {
count++;
}
}
for (long long int j = 0; j < m; j++) {
if (arr[n - 1][j] == 'D') {
count++;
}
}
cout << count << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
long long a, b, gc;
long long ga, gb, gcc;
cin >> a >> b;
gc = gcd(a, b);
gcc = a / gc * b;
ga = gcc / a;
gb = gcc / b;
if (a < b)
ga--;
else if (a > b)
gb--;
if (ga > gb)
cout << "Dasha" << endl;
else if (ga < gb)
cout << "Masha" << endl;
else
cout << "Equal" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A,B;
cin >> A >> B;
cout<<(A+B-1)/B<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
int f1 = 0, a1 = 0, c1 = 0, e1 = 0;
if (a[i][j] == 'f') f1++;
if (a[i][j] == 'a') a1++;
if (a[i][j] == 'c') c1++;
if (a[i][j] == 'e') e1++;
if (a[i][j + 1] == 'f') f1++;
if (a[i][j + 1] == 'a') a1++;
if (a[i][j + 1] == 'c') c1++;
if (a[i][j + 1] == 'e') e1++;
if (a[i + 1][j] == 'f') f1++;
if (a[i + 1][j] == 'a') a1++;
if (a[i + 1][j] == 'c') c1++;
if (a[i + 1][j] == 'e') e1++;
if (a[i + 1][j + 1] == 'f') f1++;
if (a[i + 1][j + 1] == 'a') a1++;
if (a[i + 1][j + 1] == 'c') c1++;
if (a[i + 1][j + 1] == 'e') e1++;
if (f1 == 1 && a1 == 1 && c1 == 1 && e1 == 1) {
ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int arr[3];
while (t--) {
cin >> arr[0] >> arr[1] >> arr[2];
sort(arr, arr + 3);
if (arr[0] + arr[1] >= arr[2] - 1)
cout << "Yes\n";
else
cout << "No\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 998244353;
long long int fpow(long long int a, long long int k) {
long long int r = 1;
long long int t = a;
while (k) {
if (k & 1) {
r = r * t % MOD;
}
t = t * t % MOD;
k >>= 1;
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.size();
vector<vector<long long int>> dp(n, vector<long long int>(n));
vector<long long int> f(n + 1);
for (int i = 0; i < n; i++) {
f[i + 1] = f[i];
f[i + 1] += s[i] == '?';
}
for (int len = 2; len <= n; len++) {
for (int i = 0; i < n - len + 1; i++) {
int j = i + len - 1;
if (s[i] != '(') {
dp[i][j] += dp[i + 1][j];
dp[i][j] %= MOD;
}
if (s[j] != ')') {
dp[i][j] += dp[i][j - 1];
dp[i][j] %= MOD;
}
if (s[i] != '(' && s[j] != ')') {
dp[i][j] -= dp[i + 1][j - 1];
dp[i][j] += MOD;
dp[i][j] %= MOD;
}
if (s[i] != ')' && s[j] != '(') {
dp[i][j] += dp[i + 1][j - 1];
dp[i][j] %= MOD;
dp[i][j] += fpow((long long int)2, (long long int)(f[j] - f[i + 1]));
dp[i][j] %= MOD;
}
}
}
cout << dp[0][n - 1] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char keyboard[100] = "qwertyuiopasdfghjkl;zxcvbnm,./";
char x[101];
char d;
cin >> d >> x;
if (d == 'L') {
for (int i = 0; i < strlen(x); i++) {
for (int j = 0; j < strlen(keyboard); j++) {
if (x[i] == keyboard[j]) {
cout << keyboard[j + 1];
break;
}
}
}
} else {
for (int i = 0; i < strlen(x); i++) {
for (int j = 0; j < strlen(keyboard); j++) {
if (x[i] == keyboard[j]) {
cout << keyboard[j - 1];
break;
}
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int dx[6] = {1, -1, 0, 0, 0, 0};
const int dy[6] = {0, 0, 1, -1, 0, 0};
const int dz[6] = {0, 0, 0, 0, 1, -1};
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
int n, m, t, l, r;
int bx[MAXN], by[MAXN], bz[MAXN];
vector<vector<int>> b[6];
vector<vector<vector<int>>> a;
vector<vector<vector<vector<bool>>>> vis;
void Make(vector<vector<int>> &b, int n, int m) {
b.resize(n + 2);
for (int i = 0; i <= n + 1; i++) b[i].resize(m + 2);
}
bool inside(int x, int y, int z) {
return 1 <= x && x <= n && 1 <= y && y <= m && 1 <= z && z <= t;
}
void add(int x, int y, int z, int d, int v) {
assert(!vis[x][y][z][d]);
vis[x][y][z][d] = true;
if (a[x][y][z] == 0) return;
if (v == 0) {
r++, a[x][y][z] = 0;
bx[r] = x, by[r] = y, bz[r] = z;
} else if (a[x][y][z] == -1 || a[x][y][z] == v)
a[x][y][z] = v;
else {
r++, a[x][y][z] = 0;
bx[r] = x, by[r] = y, bz[r] = z;
}
}
int main() {
read(n), read(m), read(t), l = 1;
a.resize(n + 2), vis.resize(n + 2);
for (int i = 0; i <= n + 1; i++) {
a[i].resize(m + 2);
vis[i].resize(m + 2);
for (int j = 0; j <= m + 1; j++) {
a[i][j].resize(t + 2);
vis[i][j].resize(t + 2);
for (int k = 0; k <= t + 1; k++) vis[i][j][k].resize(6);
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int k = 1; k <= t; k++) a[i][j][k] = -1;
Make(b[0], m, t);
Make(b[1], m, t);
Make(b[2], n, t);
Make(b[3], n, t);
Make(b[4], n, m);
Make(b[5], n, m);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= t; j++) {
read(b[0][i][j]);
add(1, i, j, 0, b[0][i][j]);
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= t; j++) {
read(b[1][i][j]);
add(n, i, j, 1, b[1][i][j]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= t; j++) {
read(b[2][i][j]);
add(i, 1, j, 2, b[2][i][j]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= t; j++) {
read(b[3][i][j]);
add(i, m, j, 3, b[3][i][j]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
read(b[4][i][j]);
add(i, j, 1, 4, b[4][i][j]);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
read(b[5][i][j]);
add(i, j, t, 5, b[5][i][j]);
}
while (l <= r) {
for (int i = 0; i <= 5; i++) {
int x = bx[l], y = by[l], z = bz[l], v = 0;
if (i <= 1)
v = b[i][y][z];
else if (i <= 3)
v = b[i][x][z];
else
v = b[i][x][y];
if (vis[x][y][z][i]) {
while (inside(x, y, z) && a[x][y][z] == 0) {
x += dx[i];
y += dy[i];
z += dz[i];
}
if (!inside(x, y, z)) {
if (v != 0) {
puts("-1");
return 0;
}
} else
add(x, y, z, i, v);
}
}
l++;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 1; k <= t; k++) printf("%d ", max(a[i][j][k], 0));
printf("\n");
}
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000000 + 1, mod = 1000000007;
int n;
long long dp[maxn] = {};
int main() {
int T;
scanf("%d", &T);
for (int i = 3; i < maxn; ++i)
dp[i] = (dp[i - 1] + dp[i - 2] * 2 + (!(i % 3) ? 4 : 0)) % mod;
while (T--) {
scanf("%d", &n);
printf("%d\n", dp[n]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct OP {
double flag;
int st, ed, lft;
OP() {}
OP(int a, int b, double c, int d) {
st = a;
ed = b;
flag = c;
lft = d;
}
};
struct node {
double P;
int lft, rht, flag;
void fun(double tmp) {
P *= tmp;
flag = 1;
}
};
int B[N], Z[N];
vector<OP> op;
vector<int> Y;
map<int, int> H;
struct Segtree {
node tree[N * 4 * 4];
void Pushdown(int rt) {
if (tree[rt].flag) {
tree[rt << 1].fun(tree[rt].P);
tree[rt << 1 | 1].fun(tree[rt].P);
tree[rt].flag = 0;
tree[rt].P = 1;
}
}
void build(int l, int r, int rt) {
tree[rt].lft = l;
tree[rt].rht = r;
tree[rt].P = 1;
tree[rt].flag = 0;
if (l == r) return;
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
}
void update(int L, int R, int rt, double tmp) {
int l = tree[rt].lft;
int r = tree[rt].rht;
if (L <= l && r <= R)
tree[rt].fun(tmp);
else {
Pushdown(rt);
int m = (l + r) >> 1;
if (L <= m) update(L, R, rt << 1, tmp);
if (R > m) update(L, R, rt << 1 | 1, tmp);
}
}
double query(int pos, int rt) {
int l = tree[rt].lft;
int r = tree[rt].rht;
if (l == r)
return tree[rt].P;
else {
Pushdown(rt);
int m = (l + r) >> 1;
if (pos <= m)
return query(pos, rt << 1);
else
return query(pos, rt << 1 | 1);
}
}
} seg;
int main() {
int n, m;
int i, j, k;
while (~scanf("%d %d", &n, &m)) {
Y.clear();
op.clear();
H.clear();
for (i = 0; i < n; i++) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
Y.push_back(a - b);
Y.push_back(a + b);
Y.push_back(a);
op.push_back(OP(a - b, a, (100 - c) / 100.0, 1));
op.push_back(OP(a, a + b, (100 - d) / 100.0, 0));
}
for (i = 0; i < m; i++) {
scanf("%d %d", &B[i], &Z[i]);
Y.push_back(B[i]);
}
sort(Y.begin(), Y.end());
Y.erase(unique(Y.begin(), Y.end()), Y.end());
for (i = 0; i < Y.size(); i++) H[Y[i]] = i;
seg.build(0, Y.size() - 1, 1);
for (i = 0; i < op.size(); i++) {
if (op[i].lft)
seg.update(H[op[i].st], H[op[i].ed] - 1, 1, op[i].flag);
else
seg.update(H[op[i].st] + 1, H[op[i].ed], 1, op[i].flag);
}
double ans = 0;
for (i = 0; i < m; i++) {
ans += Z[i] * seg.query(H[B[i]], 1);
}
printf("%.4f\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
int add(int a, int b) { return a + b >= Mod ? a + b - Mod : a + b; }
int dec(int a, int b) { return a - b < 0 ? a - b + Mod : a - b; }
int mul(int a, int b) { return 1ll * a * b % Mod; }
void Add(int &a, int b) { a = add(a, b); }
void Dec(int &a, int b) { a = dec(a, b); }
void Mul(int &a, int b) { a = mul(a, b); }
const int N = 1e5 + 50;
int n, a[N], pr[N], sf[N];
map<int, int> bin;
struct lll {
int a, b, c, bc, ac;
};
lll operator+(const lll &x, const lll &y) {
return (lll){add(x.a, y.a), add(x.b, y.b), add(x.c, y.c), add(x.bc, y.bc),
add(x.ac, y.ac)};
}
namespace SGT {
const int N = ::N << 2;
lll t[N];
int tb[N];
int tc[N];
int tbc[N];
int len[N];
void up(int x) { t[x] = t[x << 1] + t[x << 1 | 1]; }
void build(int x, int l, int r) {
len[x] = r - l + 1;
if (l == r) return t[x].a = l - 1, void();
build(x << 1, l, ((l + r) >> 1));
build(x << 1 | 1, ((l + r) >> 1) + 1, r);
up(x);
}
void B(int x, int v) {
Add(tb[x], v);
Add(t[x].b, mul(len[x], v));
Add(t[x].bc, mul(v, t[x].c));
Add(tbc[x], mul(v, tc[x]));
}
void C(int x, int v) {
Add(tc[x], v);
Add(t[x].c, mul(len[x], v));
Add(t[x].bc, mul(v, t[x].b));
Add(tbc[x], mul(v, tb[x]));
Add(t[x].ac, mul(v, t[x].a));
}
void BC(int x, int v) {
Add(t[x].bc, v);
Add(tbc[x], v);
}
void down(int x) {
if (tb[x]) B(x << 1, tb[x]), B(x << 1 | 1, tb[x]), tb[x] = 0;
if (tc[x]) C(x << 1, tc[x]), C(x << 1 | 1, tc[x]), tc[x] = 0;
if (tbc[x]) BC(x << 1, tbc[x]), BC(x << 1 | 1, tbc[x]), tbc[x] = 0;
}
void mdfb(int x, int l, int r, int L, int R, int v) {
if (L <= l && r <= R) return B(x, v);
down(x);
if (L <= ((l + r) >> 1)) mdfb(x << 1, l, ((l + r) >> 1), L, R, v);
if (R > ((l + r) >> 1)) mdfb(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R, v);
up(x);
}
void mdfc(int x, int l, int r, int L, int R, int v) {
if (L <= l && r <= R) return C(x, v);
down(x);
if (L <= ((l + r) >> 1)) mdfc(x << 1, l, ((l + r) >> 1), L, R, v);
if (R > ((l + r) >> 1)) mdfc(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R, v);
up(x);
}
lll ask(int x, int l, int r, int L, int R) {
if (L > R) return (lll){0};
if (L <= l && r <= R) return t[x];
down(x);
if (R <= ((l + r) >> 1)) return ask(x << 1, l, ((l + r) >> 1), L, R);
if (L > ((l + r) >> 1)) return ask(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R);
return ask(x << 1, l, ((l + r) >> 1), L, R) +
ask(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R);
}
} // namespace SGT
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
pr[i] = bin[a[i]];
bin[a[i]] = i;
}
bin.clear();
for (int i = n; i; i--) {
sf[i] = bin[a[i]];
bin[a[i]] = i;
if (!sf[i]) sf[i] = n + 1;
}
SGT ::build(1, 1, n);
static int s1[N], s2[N];
int t1 = 0, t2 = 0, mx = 0, ans = 0;
for (int i = 1; i <= n; i++) {
mx = max(mx, pr[i]);
while (t1 && pr[s1[t1]] <= pr[i]) {
int h = dec(pr[i], pr[s1[t1]]);
SGT ::mdfb(1, 1, n, s1[t1 - 1] + 1, s1[t1], h);
--t1;
}
while (t2 && sf[s2[t2]] >= sf[i]) {
int h = dec(sf[i], sf[s2[t2]]);
SGT ::mdfc(1, 1, n, s2[t2 - 1] + 1, s2[t2], h);
--t2;
}
s1[++t1] = i, s2[++t2] = i;
SGT ::mdfb(1, 1, n, i, i, pr[i]);
SGT ::mdfc(1, 1, n, i, i, sf[i]);
lll z = SGT ::ask(1, 1, n, mx + 1, i);
Dec(ans, z.bc);
Dec(ans, mul(i + 1, z.a));
Add(ans, mul(i + 1, z.b));
Add(ans, z.ac);
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long int ar[100010];
long long int chk(long long int num) {
if (num == 1) {
if (ar[num]) {
return ar[num];
} else {
ar[num] = num;
return -100;
}
}
std::vector<long long int> v;
for (long long int i = 2; i <= sqrt(num); i++) {
if (num % i == 0) {
if (num % i == i) {
v.push_back(i);
if (ar[i]) {
return ar[i];
}
} else {
v.push_back(i);
v.push_back(num / i);
if (ar[i]) {
return ar[i];
}
if (ar[num / i]) {
return ar[num / i];
}
}
}
}
if (ar[num]) {
return ar[num];
} else {
v.push_back(num);
}
for (long long int i = 0; i < v.size(); i++) {
ar[v[i]] = num;
}
return -100;
}
long long int remove(long long int num) {
if (num == 1) {
ar[num] = 0;
return 0;
}
std::vector<long long int> v;
for (long long int i = 2; i <= sqrt(num); i++) {
if (num % i == 0) {
if (num % i == i) {
v.push_back(i);
} else {
v.push_back(i);
v.push_back(num / i);
}
}
}
v.push_back(num);
for (long long int i = 0; i < v.size(); i++) {
ar[v[i]] = 0;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int T = 1;
while (T--) {
long long int n, m;
cin >> n >> m;
for (long long int j = 0; j < m; j = j + 1) {
string s;
long long int k;
cin >> s;
cin >> k;
if (s[0] == '+') {
if (ar[k] == k) {
cout << "Already on"
<< "\n";
continue;
}
long long int z = chk(k);
if (z == -100) {
cout << "Success"
<< "\n";
} else {
cout << "Conflict with " << z << "\n";
}
} else {
if (ar[k] == k) {
cout << "Success"
<< "\n";
remove(k);
} else {
cout << "Already off"
<< "\n";
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct s {
int data;
int sum;
int xu;
} a[101];
bool cmp1(s a, s b) { return a.data < b.data; }
bool cmp2(s a, s b) { return a.xu < b.xu; }
int main() {
int n, w;
int sum_1 = 0, sum_2 = 0;
scanf("%d%d", &n, &w);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].data);
a[i].xu = i;
}
sort(a, a + n, cmp1);
for (int i = 0; i < n; i++) {
sum_1 += a[i].data;
}
if (sum_1 < w || w < sum_1 / 2) {
printf("-1\n");
return 0;
} else {
for (int i = 0; i < n; i++) {
if (a[i].data % 2 == 0) {
a[i].sum = a[i].data / 2;
sum_2 += a[i].data / 2;
} else {
a[i].sum = a[i].data / 2 + 1;
sum_2 += a[i].data / 2 + 1;
}
}
}
if (sum_2 > w) {
printf("-1\n");
return 0;
} else if (sum_2 == w) {
sort(a, a + n, cmp2);
for (int i = 0; i < n; i++) {
if (i == n - 1) {
printf("%d\n", a[i].sum);
break;
}
printf("%d ", a[i].sum);
}
} else {
int x = w - sum_2;
for (int i = n - 1; i >= 0; i--) {
while (a[i].sum != a[i].data) {
a[i].sum++;
x--;
if (x == 0) break;
}
if (x == 0) break;
}
sort(a, a + n, cmp2);
for (int i = 0; i < n; i++) {
if (i == n - 1) {
printf("%d\n", a[i].sum);
break;
}
printf("%d ", a[i].sum);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
int o = sizeof(arr) / sizeof(arr[0]);
sort(arr, arr + o);
for (i = 0; i < n; i++) {
cout << arr[i] << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << '\n';
err(++it, args...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m;
cin >> n;
string str, str1;
long long cnt[26] = {0};
bool a[26] = {false}, vis[26] = {false};
cin >> str;
vector<string> s;
for (long long i = 0; i < n; i++) {
if (str[i] != '*') {
a[str[i] - 'a'] = true;
}
}
cin >> m;
for (long long i = 0; i < m; i++) {
cin >> str1;
long long t = 0;
for (long long j = 0; j < n; j++) {
if (str[j] != '*') {
if (str[j] != str1[j]) t = 1;
} else {
if (a[str1[j] - 'a']) t = 1;
}
}
if (!t) s.push_back(str1);
}
for (auto it : s) {
for (long long i = 0; i < 26; i++) {
vis[i] = false;
}
for (long long i = 0; i < n; i++) {
if (str[i] == '*' && !vis[it[i] - 'a']) {
cnt[it[i] - 'a']++, vis[it[i] - 'a'] = 1;
}
}
}
long long ans = 0;
for (long long i = 0; i < 26; i++) {
if (cnt[i] == s.size()) ans++;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<pair<long long, long long>, pair<long long, long long> > > vc;
long long n, dp[109][2009], path[109][2009];
long long maximum(long long ind, long long time) {
if (ind > n) return 0;
if (~dp[ind][time]) return dp[ind][time];
long long ret1 = maximum(ind + 1, time);
long long ret2 = -1;
if (time + vc[ind].second.first < vc[ind].first.first)
ret2 =
vc[ind].second.second + maximum(ind + 1, time + vc[ind].second.first);
if (ret1 > ret2)
path[ind][time] = 1;
else
path[ind][time] = 0;
return dp[ind][time] = max(ret1, ret2);
}
int main() {
long long t, d, p;
cin >> n;
memset(dp, -1, sizeof dp);
memset(path, -1, sizeof path);
vc.push_back({{-1, -1}, {-1, -1}});
for (long long i = 1; i <= n; i++) {
cin >> t >> d >> p;
vc.push_back({{d, i}, {t, p}});
}
sort(vc.begin(), vc.end());
cout << maximum(1, 0) << endl;
vector<long long> vv;
long long ind = 1, time = 0;
while (ind <= n) {
if (path[ind][time] == 0) {
vv.push_back(vc[ind].first.second);
time += vc[ind].second.first;
}
ind++;
}
cout << vv.size() << endl;
for (long long i = 0; i < vv.size(); i++) cout << vv[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool zero(double x) { return fabs(x) <= 1e-8; }
int sign(double x) {
if (zero(x)) return 0;
if (x > 0) return 1;
return -1;
}
struct point {
double x, y;
double tht;
point(double xx = 0.0, double yy = 0.0) {
x = xx;
y = yy;
}
void input() { scanf("%lf%lf", &x, &y); }
point operator-(const point &b) { return point(x - b.x, y - b.y); }
point operator+(const point &b) { return point(x + b.x, y + b.y); }
double operator^(const point &b) { return x * b.y - y * b.x; }
double operator*(const point &b) { return x * b.x + y * b.y; }
};
double dist(point p1, point p2) { return sqrt((p1 - p1) * (p1 - p2)); }
double dist2(point p1, point p2) { return (p1 - p2) * (p1 - p2); }
bool cmp1(point a, point b) {
if (a.y == b.y) return a.x < b.x;
return a.y < b.y;
}
point ttt;
bool cmp2(point a, point b) {
if (zero(a.tht - b.tht)) return dist2(ttt, a) < dist2(ttt, b);
return a.tht < b.tht;
}
point tubao[100050];
int tbnum;
void gettubao(vector<point> p) {
int siz = p.size();
memset(tubao, 0, sizeof(tubao));
sort(p.begin(), p.end(), cmp1);
for (int i = 1; i < siz; i++)
p[i].tht = atan2(p[i].y - p[0].y, p[i].x - p[0].x);
ttt = p[0];
sort(++p.begin(), p.end(), cmp2);
if (siz == 1) {
tbnum = 1;
tubao[0] = p[0];
return;
} else if (siz == 2) {
tbnum = 2;
tubao[0] = p[0];
tubao[1] = p[1];
return;
}
tbnum = 2;
tubao[0] = p[0];
tubao[1] = p[1];
for (int i = 2; i < siz; i++) {
while (tbnum > 1) {
if (((tubao[tbnum - 1] - tubao[tbnum - 2]) ^ (p[i] - tubao[tbnum - 2])) <=
1e-8) {
tbnum--;
} else
break;
}
tubao[tbnum++] = p[i];
}
}
vector<point> vec;
int dots_inline(point p1, point p2, point p3) {
return zero((p2 - p1) ^ (p3 - p1));
}
int dot_online_in(point p, point l1, point l2) {
return ((l1 - p) * (l2 - p)) <= 1e-8;
}
int same_side(point p1, point p2, point l1, point l2) {
return (((p1 - l1) ^ (l2 - l1)) * ((p2 - l1) ^ (l2 - l1))) > 1e-8;
}
int intersect_in(point u1, point u2, point v1, point v2) {
if (!dots_inline(u1, u2, v1) || !dots_inline(u1, u2, v2))
return !same_side(u1, u2, v1, v2) && !same_side(v1, v2, u1, u2);
return dot_online_in(u1, v1, v2) || dot_online_in(u2, v1, v2) ||
dot_online_in(v1, u1, u2) || dot_online_in(v2, u1, u2);
}
struct xishu {
double a, b, c;
};
xishu getline(point x, point y) {
struct xishu w;
w.a = y.y - x.y;
w.b = x.x - y.x;
w.c = y.x * x.y - x.x * y.y;
return w;
}
point getnode(xishu l1, xishu l2) {
point CrossP;
CrossP.x = (l1.c * l2.b - l1.b * l2.c) / (l1.a * l2.b - l1.b * l2.a) * (-1.0);
CrossP.y = (l1.c * l2.a - l1.a * l2.c) / (l1.b * l2.a - l1.a * l2.b) * (-1.0);
return CrossP;
}
int main() {
int n, p, q;
scanf("%d%d%d", &n, &p, &q);
double maxx = 0, maxy = 0;
for (int i = 0; i < n; i++) {
point p;
p.input();
maxx = ((maxx) > (p.x) ? (maxx) : (p.x));
maxy = ((maxy) > (p.y) ? (maxy) : (p.y));
vec.push_back(p);
}
vec.push_back(point(maxx, 0));
vec.push_back(point(0, maxy));
vec.push_back(point(0, 0));
gettubao(vec);
for (int i = 1; i < tbnum; i++) {
point p1 = point(0, 0);
point p2 = point(p, q);
if (sign(((p2 - p1) ^ (tubao[i] - p1)) *
((p2 - p1) ^ (tubao[(i + 1) % tbnum] - p1))) <= 0) {
xishu l1 = getline(point(0, 0), point(p, q));
xishu l2 = getline(tubao[i], tubao[(i + 1) % tbnum]);
point ans = getnode(l1, l2);
printf("%.16f\n", p / ans.x);
return 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N=120;
int a[N];
int n,u,v;
int solve() {
bool allsame = true;
for (int i = 1; i < n; i++) {
if (abs(a[i]-a[i-1]) > 1) return 0;
if (a[i] != a[i-1]) allsame = false;
}
if (allsame) return min(2*v,u+v);
return min(u,v);
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &n, &u, &v);
for (int i = 0; i < n; i++) {
scanf("%d", a+i);
}
printf("%d\n", solve());
}
} | 2 |
#include <cstdio>
#include <vector>
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <tuple>
#include <utility>
#include <queue>
using namespace std;
using AnsType = long long int;
const AnsType INF = 1LL << 60;
int pow3[10];
int get_digit(int val, int k) {
val /= pow3[k];
return val % 3;
}
string tri_to_string(int val, int lim) {
string res = "";
for(int i=0; i<lim; i++) {
res += (char)('0' + get_digit(val, i));
}
return res;
}
int modify_digit(int bit, int k, int val) {
int b = get_digit(bit, k);
bit -= pow3[k] * b;
bit += pow3[k] * val;
return bit;
}
struct Elem {
int pos, bit;
AnsType cost;
Elem() {}
Elem(int a, int b, AnsType c) : pos(a), bit(b), cost(c) {}
bool operator<(const Elem &e) const {
return cost > e.cost;
}
};
using Graph = vector< vector< pair<int, int> > >;
int main() {
int N, M, K, P; cin >> N >> M >> K >> P; P--;
Graph G(N);
for(int i=0; i<M; i++) {
int x, y, m; cin >> x >> y >> m;
x--; y--;
G[x].emplace_back(y, m);
G[y].emplace_back(x, m);
}
vector< vector<int> > S(N), T(N);
for(int i=0; i<K; i++) {
int s, t; cin >> s >> t;
s--; t--;
S[s].emplace_back(i);
T[t].emplace_back(i);
}
pow3[0] = 1;
for(int i=1; i<=K; i++) pow3[i] = pow3[i-1] * 3;
int fullbit = pow3[K] - 1;
priority_queue<Elem> que;
vector< vector<AnsType> > dist(N, vector<AnsType>(pow3[K], INF));
dist[P][0] = 0;
que.emplace(P, 0, 0);
while(que.size()) {
auto cur = que.top(); que.pop();
int pos = cur.pos, bit = cur.bit;
AnsType d = cur.cost;
if(d > dist[pos][bit]) continue;
// fprintf(stderr, "pos = %d, bit = %s, d = %lld\n", pos + 1, tri_to_string(bit, K).c_str(), d);
{
int nbit = bit;
for(auto s : S[pos]) {
int v = get_digit(nbit, s);
if(v != 0) continue;
nbit = modify_digit(nbit, s, v + 1);
}
for(auto t : T[pos]) {
int v = get_digit(nbit, t);
if(v != 1) continue;
nbit = modify_digit(nbit, t, v + 1);
}
if(dist[pos][nbit] > d) {
dist[pos][nbit] = d;
que.emplace(pos, nbit, d);
}
}
for(auto e : G[pos]) {
int to, c; tie(to, c) = e;
// fprintf(stderr, "e: to = %d, c = %d\n", to, c);
int nbit = bit;
if(dist[to][nbit] > d + c) {
// fprintf(stderr, "cur = %d, to = %d\n", pos, to);
dist[to][nbit] = d + c;
que.emplace(to, nbit, d + c);
}
}
}
AnsType ans = INF;
for(int i=0; i<N; i++) {
ans = min(ans, dist[i][fullbit]);
}
if(ans == INF) cout << "Cannot deliver" << endl;
else cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int maxn = 2 * (int)1e5 + 1000;
int n, m, tot = 1, fa[maxn], vis[maxn], in[maxn], out[maxn], pa[maxn],
dep[maxn];
vector<vector<int> > g(maxn);
int find_root(int x) {
if (x == fa[x])
return fa[x];
else {
return fa[x] = find_root(fa[x]);
}
}
void uni_root(int a, int b) {
int aa = find_root(a);
int bb = find_root(b);
if (aa != bb) {
fa[bb] = aa;
}
}
bool belong(int a, int b) {
if (in[a] <= in[b] && out[b] <= out[a]) return true;
return false;
}
void dfs(int u, int par) {
in[u] = tot++;
if (par) pa[u] = par;
if (par) dep[u] = dep[par] + 1;
for (int to : g[u]) {
if (to == par) continue;
dfs(to, u);
}
out[u] = tot;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
cin >> n >> m;
for (int i = 1; i <= (int)(n); ++i) pa[i] = i;
for (int i = 0; i < (int)(n - 1); ++i) {
int u, v;
cin >> u >> v;
g[u].emplace_back(v);
g[v].emplace_back(u);
}
memset(vis, 0, sizeof(vis));
memset(dep, 0, sizeof(dep));
dfs(1, 0);
for (int i = 0; i < (int)(m); ++i) {
bool ok = true;
int k;
cin >> k;
vector<pair<int, int> > v(k);
for (int i = 0; i < (int)(k); ++i) {
int x;
cin >> x;
v[i] = {dep[x], x};
}
sort((v).begin(), (v).end());
int leaf = v[k - 1].second;
for (int i = 0; i < k - 1; ++i) {
v[i].second = pa[v[i].second];
}
for (int i = 0; i < k - 1; ++i) {
if (!belong(v[i].second, leaf)) {
ok = false;
break;
}
}
cout << (ok ? "YES" : "NO") << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define inf 100000000
using namespace std;
int main(){
int simen[200]={};
for(int i=0;i<200;i++)simen[i] = (i+1) * (i+2) * (i+3) / 6;
int dp[1000005], kisudp[1000005];
for(int i=0;i<1000005;i++){dp[i] = inf; kisudp[i] = inf;}
dp[0]=0;kisudp[0]=0;
for(int k=0;k<200;k++)for(int i=1;i<1000005;i++){
if(i >= simen[k])dp[i] = min(dp[i], dp[i-simen[k]] + 1);
}
for(int k=0;k<200;k++)for(int i=1;i<1000005;i++){
if(i >= simen[k] && simen[k]%2 == 1)kisudp[i] = min(kisudp[i], kisudp[i-simen[k]] + 1);
}
while(1){
int N;
scanf("%d", &N);
if(N==0)break;
else printf("%d %d\n", dp[N], kisudp[N]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool fs(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
int parent[200005];
int mark[200005];
void initializeSet(int n) {
for (int i = 1; i <= n; i++) parent[i] = i;
}
int findParent(int x) {
if (x == parent[x])
return x;
else
return parent[x] = findParent(parent[x]);
}
int unionSet(int x, int y) {
int px = findParent(x);
int py = findParent(y);
if (px == py)
return 1;
else
parent[py] = px;
return 0;
}
int main() {
int n, m, cnt = 0, a, b;
vector<pair<int, int> > v;
cin >> n >> m;
initializeSet(n);
for (int i = 0; i < m; i++) {
cin >> a >> b;
mark[a]++;
mark[b]++;
v.push_back(make_pair(a, b));
}
for (int i = 0; i < m; i++) {
a = v[i].first;
b = v[i].second;
if (mark[a] == 2 && mark[b] == 2) cnt += unionSet(a, b);
}
cout << cnt << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a, b, i;
cin >> n >> m;
vector<pair<long long, long long> > v;
for (i = 0; i < n; i++) {
cin >> a >> b;
v.push_back({a, b});
}
if (v[0].first != 0) {
cout << "NO";
return 0;
}
long long start = 0, end = 0;
for (i = 0; i < n - 1; i++) {
start = v[i + 1].first;
if (v[i].second > end) end = v[i].second;
if (start > end) {
cout << "NO";
return 0;
}
}
for (i = 0; i < n; i++) {
if (v[i].second == m) {
cout << "YES";
return 0;
}
}
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, D, A, B, Q, op, p, v;
int tree[2][200100], lo[200100], hi[200100];
void update(int *Tree, int p, int v) {
assert(p > 0);
while (p < 200100) {
Tree[p] += v;
p += p & -p;
}
}
int query(int *Tree, int p) {
int ret = 0;
while (p > 0) {
ret += Tree[p];
p -= p & (-p);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> D >> A >> B >> Q;
for (int q = 0; q < Q; q++) {
cin >> op;
if (op == 1) {
cin >> p >> v;
int lo2 = min(B, lo[p] + v);
update(tree[0], p, lo2 - lo[p]);
lo[p] = lo2;
int hi2 = min(A, hi[p] + v);
update(tree[1], p, hi2 - hi[p]);
hi[p] = hi2;
} else {
cin >> p;
cout << query(tree[0], p - 1) + query(tree[1], N) -
query(tree[1], p + D - 1)
<< "\n";
}
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int a[2000][2000]={};
int main(){
int n,f;
//int a[2000][2000]={};
map<string,int> M;
map<int,string> MD;
set<string> S;
int c=0;
int count=0;
cin>>n>>f;
for(int i=0;i<n;i++){
int m;
cin>>m;
vector<string> st;
for(int t=0;t<m;t++){
string s;
cin>>s;
st.push_back(s);
if(S.find(s)==S.end()){S.insert(s); MD[count]=s; M[s]=count; count++;}
for(int h=0;h<st.size()-1;h++){
a[M[s]][M[st[h]]]++;
a[M[st[h]]][M[s]]++;
if(a[M[st[h]]][M[s]]==f){c++;}
}
}
}
cout<<c<<endl;
for(set<string>::iterator i=S.begin();i!=S.end();i++){
for(set<string>::iterator t=i;t!=S.end();t++){
if(a[M[(*i)]][M[(*t)]]>=f){
cout<<(*i)<<" "<<(*t)<<endl;
}
}
}
return 0;
}
| 0 |
#include<iostream>
#include<vector>
using namespace std;
const int N = 100000 ;
int size,
c,
l[N],
r[N],
b[2*N+1];
vector<int> vec[N];
void dfs(int v){
l[v] = ++c;
for(int i=0;i<vec[v].size();i++){
dfs(vec[v][i]);
}
r[v] = ++c;
}
void add(int i,int x){
while(i<=size){
b[i] += x;
i += i&-i;
}
}
int getSum(int i){
int ans = 0;
while(i>0){
ans += b[i];
i -= i&-i;
}
return ans;
}
void queryChoose(int i){
if(i == 0){
int v,w;
cin>>v>>w;
add(l[v],w);
add(r[v],-w);
}else{
int v;
cin>>v;
cout<<getSum(r[v] - 1)<<endl;
}
}
int main(){
int n;
while(cin>>n){
c = 0;
size = 2*n + 1;
for(int i=0;i<n;i++){
int k;
cin>>k;
for(int j=0;j<k;j++){
int child;
cin>>child;
vec[i].push_back(child);
}
}
dfs(0);
int q;
cin>>q;
for(int i=0;i<q;i++){
int op;
cin>>op;
queryChoose(op);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int N;
cin >> N;
string s;
cin >> s;
if (N & 1)
cout << ":(";
else {
int flag = 0, g = 0, l = 0, r = 0;
for (int i = 0; i < N; i++) {
if (s[i] == '(')
l++;
else if (s[i] == ')')
r++;
}
int h = 0, j = 0;
for (int i = 0; i < N; i++) {
if (s[i] == '?') {
if (l < N / 2)
s[i] = '(', l++, h++;
else
s[i] = ')', r++, j++;
} else if (s[i] == '(')
h++;
else
j++;
if (j > h || (j == h && i < N - 1)) flag = 1;
}
if (l == r && !flag)
cout << s;
else
cout << ":(";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tostr(const T& t) {
ostringstream os;
os << t;
return os.str();
}
vector<string> G;
bool vis[15][15][15][15];
int dr[] = {2, -2, 2, -2};
int dc[] = {2, 2, -2, -2};
bool calc() {
memset(vis, false, sizeof vis);
int r1, c1, r2, c2;
r1 = -1;
for (int i = (int)(0); i <= (int)(8 - 1); ++i) {
for (int j = (int)(0); j <= (int)(8 - 1); ++j) {
if (G[i][j] == 'K') {
if (r1 == -1) {
r1 = i;
c1 = j;
} else {
r2 = i;
c2 = j;
}
}
}
}
queue<int> q;
q.push(r1);
q.push(c1);
q.push(r2);
q.push(c2);
while (!q.empty()) {
r1 = q.front();
q.pop();
c1 = q.front();
q.pop();
r2 = q.front();
q.pop();
c2 = q.front();
q.pop();
if (r1 == r2 && c1 == c2 && G[r1][c1] != '#') return true;
if (vis[r1][c1][r2][c2]) continue;
vis[r1][c1][r2][c2] = true;
for (int i = (int)(0); i <= (int)(4 - 1); ++i) {
int nr1 = r1 + dr[i];
int nc1 = c1 + dc[i];
if (nr1 < 0 || nr1 >= 8 || nc1 < 0 || nc1 >= 8) continue;
for (int j = (int)(0); j <= (int)(4 - 1); ++j) {
int nr2 = r2 + dr[j];
int nc2 = c2 + dc[j];
if (nr2 < 0 || nr2 >= 8 || nc2 < 0 || nc2 >= 8) continue;
q.push(nr1);
q.push(nc1);
q.push(nr2);
q.push(nc2);
}
}
}
return false;
}
int main() {
int ntests;
cin >> ntests;
for (int testnum = (int)(0); testnum <= (int)(ntests - 1); ++testnum) {
G.clear();
for (int i = (int)(0); i <= (int)(8 - 1); ++i) {
string s;
cin >> s;
G.push_back(s);
}
bool ans = calc();
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct line {
long long m, y0;
line(long long y0 = 0, long long m = 0) : y0(y0), m(m) {}
};
struct ConvexHullTrick {
int pos = 0;
bool check(line a, line b, line c) {
return (a.y0 - b.y0) * (c.m - a.m) < (a.y0 - c.y0) * (b.m - a.m);
}
vector<line> H;
void update(line l) {
if (H.size() >= 1 && l.m == H.back().m) {
if (l.y0 >= H.back().y0) return;
H.pop_back();
}
while (H.size() >= 2 && !check(H[H.size() - 2], H[H.size() - 1], l))
H.pop_back();
H.push_back(l);
}
long long eval(int id, int x) { return H[id].y0 + H[id].m * x; }
long long query(int x) {
while (pos + 1 < H.size() && eval(pos, x) > eval(pos + 1, x)) ++pos;
return eval(pos, x);
}
};
const int N = 1e5 + 7;
ConvexHullTrick c[5 * N];
pair<int, int> a[N];
long long ac[N], ans[N];
int x[N], y[N];
void update(int n, int b, int e, int pos, line l) {
c[n].update(l);
if (b == e) return;
int m = (b + e) / 2;
if (pos <= m)
update(2 * n, b, m, pos, l);
else
update(2 * n + 1, m + 1, e, pos, l);
}
long long query(int n, int b, int e, int i, int j, int x) {
if (b > j || e < i) return 1e16;
if (b >= i && e <= j) return c[n].query(x);
int m = (b + e) / 2;
return min(query(2 * n, b, m, i, j, x), query(2 * n + 1, m + 1, e, i, j, x));
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
ac[i] = ac[i - 1] + a[i].first;
}
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
update(1, 1, n, a[i].second,
line(1ll * a[i].first * a[i].second - ac[a[i].second], a[i].first));
}
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x[i], &y[i]);
a[i].first = x[i] - y[i];
a[i].second = i;
}
sort(a + 1, a + q + 1);
for (int i = 1; i <= q; i++) {
int j = a[i].second;
ans[j] = ac[y[j]] + query(1, 1, n, y[j] - x[j] + 1, y[j], x[j] - y[j]);
}
for (int i = 1; i <= q; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int ans = pow(2, n / 2 + 1);
cout << ans - 2 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXS = 2e4;
int sizeL = MAXS, sizeR = MAXS;
bool vis[MAXS];
int par[MAXS];
vector<int> adj[MAXS];
bool match(int u) {
for (int v : adj[u]) {
if (vis[v]) continue;
vis[v] = true;
if (par[v] == -1 || match(par[v])) {
par[v] = u;
return true;
}
}
return false;
}
int maxmatch() {
fill_n(par, sizeR, -1);
int ret = 0;
for (int i = 0; i < sizeL; i++) {
fill_n(vis, sizeR, false);
ret += match(i);
}
return ret;
}
long long try_board(int n, int m) {
vector<vector<int> > idxl(n, vector<int>(m, 0)), idxr(n, vector<int>(m, 0));
int nl = 0, nr = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if ((i + j) % 2 == 0) {
idxl[i][j] = nl++;
} else {
idxr[i][j] = nr++;
}
}
}
sizeL = nl;
sizeR = nr;
for (auto i = (0); i != (nl); ++i) adj[i].clear();
for (int i = 0; i < n; i++) {
for (int first = 0; first < n; first++) {
if (abs(i - first) >= 3) continue;
for (int j = 0; j < m; j++) {
if ((i + j) % 2 != 0) continue;
for (int second = 0; second < m; second++) {
int d = abs(i - first) + abs(j - second);
if (d != 3) continue;
assert((first + second) % 2 == 1);
adj[idxl[i][j]].push_back(idxr[first][second]);
}
}
}
}
return 2LL * maxmatch();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int N, M;
cin >> N >> M;
if (N > M) swap(N, M);
int rN = N % 6, rM = M % 6;
long long ret = 1LL * N * M - 1LL * (rN * rM);
for (int qN = 0; qN < 10 && 6 * qN + rN <= N; qN++) {
for (int qM = 0; qM < 10 && 6 * qM + rM <= M; qM++) {
int sn = 6 * qN + rN;
int sm = 6 * qM + rM;
long long alt = 1LL * N * M;
alt -= 1LL * sn * sm;
alt += try_board(sn, sm);
ret = max(ret, alt);
}
}
if (N == 2) {
int tmp[4] = {0, -2, -4, -2};
ret = max(ret, 2LL * M + tmp[M % 4]);
}
cout << ret << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const long long int Inf = 1LL << 62;
unordered_map<int, int> cntup, cntlw, duplicate;
unordered_set<int> up, lw;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int x, y, n, need;
cin >> n;
need = n / 2 + (n & 1);
while (n--) {
cin >> x >> y;
up.insert(x);
cntup[x]++;
lw.insert(y);
cntlw[y]++;
if (x == y) {
duplicate[x]++;
}
}
int ans = 1e9;
for (int x : up) {
cntlw[x] -= duplicate[x];
if (cntup[x] >= need) {
cout << 0 << endl;
return 0;
} else if (cntup[x] + cntlw[x] >= need) {
ans = min(ans, need - cntup[x]);
}
cntlw[x] += duplicate[x];
}
for (int x : lw) {
cntup[x] -= duplicate[x];
int lagbe = need - cntup[x];
if (lagbe <= 0) {
cout << 0 << endl;
return 0;
} else if (cntup[x] + cntlw[x] >= need) {
ans = min(ans, need - cntup[x]);
}
cntlw[x] += duplicate[x];
}
if (ans == 1e9) {
ans = -1;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <cstring>
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, n) for(int i = 0; i < (n); i++)
#define MP make_pair
#define X first
#define Y second
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> P;
const int INF = 1<<29;
int field[100][100];
int visit[100][100];
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int w, h;
int dfs(int x, int y){
int res = 0;
rep(i, 4){
int nx = x+dx[i], ny = y+dy[i];
if(nx < 0 || nx >= w || ny < 0 || ny >= h) continue;
if(!field[ny][nx]) continue;
if(visit[ny][nx]) continue;
visit[ny][nx] = 1;
res = max(res, dfs(nx, ny));
visit[ny][nx] = 0;
}
return res+1;
}
int main(){
while(cin >> w >> h, w|h){
rep(i, h) rep(j, w) cin >> field[i][j];
int ans = 0;
rep(i, h) rep(j, w){
if(field[i][j]){
memset(visit, 0, sizeof(visit));
visit[i][j] = 1;
ans = max(ans, dfs(j, i));
}
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int q;
cin >> q;
string prev;
cin >> prev;
q--;
set<string> s;
s.insert(prev);
bool ok = true;
while(q--)
{
string next;
cin >> next;
ok &= next.front() == prev.back();
ok &= (not s.count(next));
s.insert(next);
prev = next;
}
cout << (ok ? "Yes" : "No") << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char ans[11000][11000];
char a[10] = {"aeiou"};
int main() {
int k;
int flag = 0;
cin >> k;
for (int i = 5; i <= k; i++) {
if (k % i == 0 && k / i >= 5) {
flag = i;
break;
}
}
if (!flag) {
cout << "-1" << endl;
return 0;
}
int n = flag;
int m = k / n;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
ans[i][j] = a[(i + j) % 5];
}
}
for (int i = 5; i < n; i++) {
for (int j = 0; j < 5; j++) {
ans[i][j] = a[j];
}
for (int j = 5; j < m; j++) {
ans[i][j] = 'm';
}
}
for (int i = 5; i < m; i++) {
for (int j = 0; j < 5; j++) {
ans[j][i] = a[j];
}
for (int j = 5; j < n; j++) {
ans[j][i] = 'm';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ans[i][j];
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10;
int h[N][N];
int f[N * N];
double dp[N * N];
pair<int, int> coord(int i) {
int r = i / N;
int c = i % N;
if (r & 1) c = N - c - 1;
return {r, c};
}
int getidx(int r, int c) {
if (r & 1) c = N - c - 1;
return N * r + c;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cin >> h[i][j];
f[getidx(i, j)] = getidx(i - h[i][j], j);
}
}
for (int i = 0; i < N * N; i++) {
pair<int, int> p = coord(i);
h[p.first][p.second] = i;
}
dp[0] = 0;
dp[1] = 6.0 + dp[0];
dp[2] = 3.0 + 0.5 * (dp[0] + dp[1]);
dp[3] = 2.0 + (dp[0] + dp[1] + dp[2]) / 3.0;
dp[4] = 1.5 + (dp[0] + dp[1] + dp[2] + dp[3]) / 4.0;
dp[5] = 1.2 + (dp[0] + dp[1] + dp[2] + dp[3] + dp[4]) / 5.0;
for (int i = 6; i < N * N; i++) {
for (int j = 0; j < 6; j++) {
dp[i] += min(dp[i - j - 1], dp[f[i - j - 1]]);
}
dp[i] = 1 + dp[i] / 6.0;
}
cout << fixed << setprecision(8) << dp[N * N - 1] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int maxm = 50;
int edge[maxm + 1][maxm + 1];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
if (u <= maxm && v <= maxm) edge[u][v] = edge[v][u] = 1;
}
for (int i = 1; i <= min(n, maxm); ++i) {
for (int j = i + 1; j <= min(n, maxm); ++j) {
for (int k = j + 1; k <= min(n, maxm); ++k) {
if (!(edge[i][j] && edge[i][k] && edge[j][k] ||
!edge[i][j] && !edge[i][k] && !edge[j][k]))
continue;
for (int h = k + 1; h <= min(n, maxm); ++h) {
if (!(edge[i][j] && edge[i][h] && edge[j][h] && edge[k][h] ||
!edge[i][j] && !edge[i][h] && !edge[j][h] && !edge[k][h]))
continue;
for (int l = h + 1; l <= min(n, maxm); ++l) {
if (!(edge[i][j] && edge[i][l] && edge[j][l] && edge[k][l] &&
edge[h][l] ||
!edge[i][j] && !edge[i][l] && !edge[j][l] && !edge[k][l] &&
!edge[h][l]))
continue;
return printf("%d %d %d %d %d\n", i, j, k, h, l), 0;
}
}
}
}
}
printf("-1\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int tx[]={0,0,1,-1};
const int ty[]={1,-1,0,0};
int getd(int a,int b,int x,int y){
return abs(a-x)+abs(b-y);
}
char getc(int &a,int &b,int d,int x,int y){
int Mn=2e9,op=-1;
for (int i=0;i<4;i++){
int xx=a+tx[i]*d,yy=b+ty[i]*d;
int dis=getd(xx,yy,x,y);
if (dis<Mn) {Mn=dis; op=i;}
}
a=a+tx[op]*d; b=b+ty[op]*d;
if (op==0) return 'U';
if (op==1) return 'D';
if (op==2) return 'R';
return 'L';
}
int x[1111],y[1111],d[222],cnt[2],m;
signed main(){
int T; scanf("%lld",&T);
for (int i=1;i<=T;i++){
scanf("%lld%lld",&x[i],&y[i]);
cnt[(x[i]+y[i])%2]++;
}
if (cnt[1]&& cnt[0]) return puts("-1"),0;
for (int i=0;i<=30;i++) d[i+1]=1<<(30-i);
if (cnt[0]) d[32]=1,m=32; else m=31;
printf("%lld\n",m);
for (int i=1;i<=m;i++) printf("%lld ",d[i]); puts("");
for (int i=1;i<=T;i++){
int a=0,b=0;
for (int j=1;j<=m;j++)
putchar(getc(a,b,d[j],x[i],y[i]));
puts("");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double dp[305][305][305];
double dish(int a,int b,int c,int n){
if(a<0 or b<0 or c<0)
return 0;
if(a==0 and b==0 and c==0)
dp[a][b][c]=0;
if(dp[a][b][c]==-1){
dp[a][b][c]=(a*dish(a-1,b+1,c,n)+b*dish(a,b-1,c+1,n)+c*dish(a,b,c-1,n)+n)/(a+b+c);
}
return dp[a][b][c];
}
int main(){
int n;
cin >> n;
std::fill_n(&dp[0][0][0],305*305*305,-1.0);
int a=0,b=0,c=0;
for(int i=0;i<n;i++){
int x;
cin >> x;
if(x==3)
a++;
else if(x==2)
b++;
else
c++;
}
cout << setprecision(50) << dish(a,b,c,n) << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size() / 2; i++)
if (s[i] != s[s.size() - i - 1]) {
cout << "NO";
return 0;
}
for (int i = 0; i < s.size(); i++)
if ((s[i] != 'A') && (s[i] != 'W') && (s[i] != 'T') && (s[i] != 'Y') &&
(s[i] != 'U') && (s[i] != 'I') && (s[i] != 'O') && (s[i] != 'H') &&
(s[i] != 'X') && (s[i] != 'V') && (s[i] != 'M')) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool divc[100001][318];
int sum[100001][318];
int n;
int x[100001], y[100001];
set<pair<int, int> > comp;
int main() {
memset(divc, 0, sizeof(divc));
memset(sum, 0, sizeof(sum));
comp.clear();
cin >> n;
for (int i = 0; i < (int)(n); i++) cin >> x[i + 1] >> y[i + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j < 318; j++) {
if (x[i] % j == 0) {
divc[i][j] = 1;
sum[i][j]++;
int c = x[i] / j;
if (c >= 318) {
comp.insert(make_pair(c, i));
}
}
if (i + 1 < 100001) {
sum[i + 1][j] = sum[i][j];
}
}
}
for (int i = 1; i <= n; i++) {
int ans = 0;
for (int j = 1; j < 318; j++) {
if (!divc[i][j]) continue;
if (!(sum[i - 1][j] - sum[i - y[i] - 1][j])) {
ans++;
}
int c = x[i] / j;
if (c >= 318) {
set<pair<int, int> >::iterator it = comp.lower_bound(make_pair(c, i));
if (it != comp.begin()) {
it--;
if (it->first != c || it->second < i - y[i]) {
ans++;
}
} else {
ans++;
}
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:512000000")
template <class T>
T sqr(T a) {
return a * a;
}
int n;
vector<vector<int> > g;
int val[1 << 17];
bool was[1 << 17] = {0};
pair<long long, long long> dfs(int v) {
was[v] = 1;
long long d1 = 0, d2 = 0;
for (int i = 0; i < (int)(g[v]).size(); ++i) {
int to = g[v][i];
if (was[to]) continue;
pair<long long, long long> r = dfs(to);
d1 = min(d1, r.first);
d2 = max(d2, r.second);
}
int tval = val[v] + d1 + d2;
if (tval > 0)
d1 -= tval;
else
d2 -= tval;
return make_pair(d1, d2);
}
int main() {
scanf("%d", &n);
g.resize(n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < n; ++i) scanf("%d", &val[i]);
pair<long long, long long> res = dfs(0);
cout << res.second - res.first << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 312345;
int n, mx, fa[maxn][20], dep[maxn];
vector<int> v1, v2;
inline int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int det = dep[u] - dep[v];
for (int i = 0; i < 20; ++i)
if (det >> i & 1) u = fa[u][i];
if (u == v) return u;
for (int i = 19; i >= 0; --i)
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
return fa[u][0];
}
inline int dis(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
int main() {
for (int i = 0; i < 20; ++i) fa[1][i] = 1;
v1.push_back(1);
scanf("%d", &n);
for (int u = 2; u <= n + 1; ++u) {
int x;
scanf("%d", &x);
dep[u] = dep[x] + 1;
fa[u][0] = x;
for (int i = 1; i < 20; ++i) fa[u][i] = fa[fa[u][i - 1]][i - 1];
int d1 = dis(u, v1[0]);
int d2 = !v2.size() ? 0 : dis(u, v2[0]);
if (max(d1, d2) == mx) {
if (d2 == mx)
v1.push_back(u);
else
v2.push_back(u);
} else if (max(d1, d2) > mx) {
mx = max(d1, d2);
if (d2 == mx) {
for (auto v : v1)
if (dis(u, v) == mx) v2.push_back(v);
v1.clear();
v1.push_back(u);
} else {
v2.clear();
v2.push_back(u);
}
}
printf("%d\n", v1.size() + v2.size());
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long sumofdigit(long long n) {
long long ans = 0;
while (n) {
ans += (n % 10);
n = n / 10;
}
return ans;
}
long long power(long long n, long long p) {
long long res = n;
for (long long i = 1; i < p; i++) {
res *= n;
}
return res;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<long long> ans;
long long a, b, c;
cin >> a >> b >> c;
for (long long i = 1; i <= 81; i++) {
long long x = power(i, a) * b + c;
if (x > 1e9) {
break;
}
if (sumofdigit(x) == i) {
ans.push_back(x);
}
}
cout << ans.size() << "\n";
for (auto i : ans) {
cout << i << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, s = 0, d = 0;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
while (!v.empty()) {
if (v[0] >= v[v.size() - 1]) {
s += v[0];
v.erase(v.begin());
} else {
s += v[v.size() - 1];
v.erase(v.end() - 1);
}
if (!v.empty() && v[0] >= v[v.size() - 1]) {
d += v[0];
v.erase(v.begin());
} else if (!v.empty() && v[0] < v[v.size() - 1]) {
d += v[v.size() - 1];
v.erase(v.end() - 1);
}
}
cout << s << " " << d;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
struct block{
double xr;
double xl;
double g;
set<int> chil;
};
int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};
int w,h;
int inde=1;
bool isrange(int i,int j){
return 0<=i && i<h && 0<=j && j<w;
}
void draw(int i,int j,char x,vector<string> &f,vector<vector<int>> &c){
f[i][j]='.';
c[i][j]=inde;
for(int dir=0;dir<4;dir++){
int toi=i+dx[dir];
int toj=j+dy[dir];
if(isrange(toi,toj) && f[toi][toj]==x){
draw(toi,toj,x,f,c);
}
}
return;
}
vector<block> bs;
pair<double,double> gggg(int x){
double gg=bs[x].g;
double wei=4;
for(auto b:bs[x].chil){
auto ret=gggg(b);
gg=(ret.first*ret.second+wei*gg)/(wei+ret.first);
wei+=ret.first;
}
return make_pair(wei,gg);
}
int main(){
while(cin>>w>>h,w){
vector<string> f(h);
for(int i=0;i<h;i++) cin>>f[i];
vector<vector<int>> c(h,vector<int>(w,0));
inde=1;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(isdigit(f[i][j])){
draw(i,j,f[i][j],f,c);
inde++;
}
}
}
bs.clear();
bs.resize(inde);
for(int i=0;i<inde;i++){
bs[i].xl=400000;
bs[i].xr=0;
bs[i].g=0;
}
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(c[i][j]!=0){
bs[c[i][j]].g+=j;
for(int dir=0;dir<2;dir++){
int toi=i+dx[dir];
int toj=j;
if(isrange(toi,toj)&&c[toi][toj]!=0 && c[toi][toj]!=c[i][j]){
if(dir==0){
bs[c[i][j]].xl=min<double>(bs[c[i][j]].xl,j);
bs[c[i][j]].xr=max<double>(bs[c[i][j]].xr,j);
}
else{
bs[c[i][j]].chil.insert(c[toi][toj]);
}
}
else if(!isrange(toi,toj) && dir==0){
bs[c[i][j]].xl=min<double>(bs[c[i][j]].xl,j);
bs[c[i][j]].xr=max<double>(bs[c[i][j]].xr,j);
}
}
}
}
}
for(int i=0;i<inde;i++) {
bs[i].g/=4;
bs[i].xl-=0.5;
bs[i].xr+=0.5;
}
bool isok=true;
for(int i=1;i<inde;i++){
auto ret=gggg(i);
isok&=(bs[i].xl<ret.second && ret.second<bs[i].xr);
}
cout<<(isok ? "STABLE" : "UNSTABLE")<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct _ {
ios_base::Init i;
_() {
cin.sync_with_stdio(0);
cin.tie(0);
}
} _;
double a[500];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i];
double ans = 0;
for (int i = 0; i < m; ++i) {
int from, to;
double x;
cin >> from >> to >> x;
--from;
--to;
ans = max(ans, (a[from] + a[to]) / x);
}
cout.precision(20);
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 100005, note = 100;
int C[MN], W[MN], czy[MN], ile[MN];
priority_queue<pair<long long, int> > Q;
long long wynik;
int main() {
int n;
long long hajs;
scanf("%d%I64d", &n, &hajs);
for (int i = 1; i <= n; ++i) {
scanf("%d", &C[i]);
ile[i] = C[i] / note;
C[i] %= note;
}
for (int i = 1; i <= n; ++i) scanf("%d", &W[i]);
for (int i = 1; i <= n; ++i) {
if (!C[i]) continue;
long long currDis = ((long long)(note - C[i])) * ((long long)W[i]);
if (C[i] <= hajs) {
hajs -= C[i];
Q.push(make_pair(-currDis, i));
czy[i] = 1;
} else {
if (!Q.empty() && -Q.top().first < currDis) {
czy[Q.top().second] = 0;
czy[i] = 1;
wynik -= Q.top().first;
Q.pop();
Q.push(make_pair(-currDis, i));
} else {
wynik += currDis;
}
hajs += (100 - C[i]);
}
}
printf("%I64d\n", wynik);
for (int i = 1; i <= n; ++i) {
if (czy[i] || !C[i])
printf("%d %d\n", ile[i], C[i]);
else
printf("%d 0\n", ile[i] + 1);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char grid[2010][2010];
bool vis[2010][2010];
int dx[] = {0, 0, 1, -1};
int dy[] = {-1, 1, 0, 0};
bool valid(int x, int y, int n, int m) {
if (x == n || y == m || x == -1 || y == -1 || vis[x][y] ||
grid[x][y] == '*') {
return 0;
}
return 1;
}
int main() {
int n, m;
int sr, sc;
int x, y;
scanf("%d%d%d%d%d%d", &n, &m, &sr, &sc, &x, &y);
sr--, sc--;
for (int i = 0; i < n; i++) {
scanf("%s", grid[i]);
}
int ans = 0;
queue<pair<pair<int, int>, pair<int, int> > > q[2];
int curQ = 0, nxtQ = 1;
q[curQ].push(make_pair(make_pair(sr, sc), make_pair(x, y)));
while (q[curQ].size()) {
while (q[curQ].size()) {
pair<pair<int, int>, pair<int, int> > cur = q[curQ].front();
q[curQ].pop();
int curX = cur.first.first;
int curY = cur.first.second;
int rem[] = {cur.second.first, cur.second.second};
if (valid(curX, curY, n, m) == 0) {
continue;
}
ans++;
vis[curX][curY] = 1;
for (int i = 0; i < 4; i++) {
if (i < 2) {
if (rem[i] == 0) continue;
rem[i]--;
q[nxtQ].push(make_pair(make_pair(curX + dx[i], curY + dy[i]),
make_pair(rem[0], rem[1])));
rem[i]++;
} else {
q[curQ].push(make_pair(make_pair(curX + dx[i], curY + dy[i]),
make_pair(rem[0], rem[1])));
}
}
}
curQ = !curQ;
nxtQ = !nxtQ;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define ll long long
#define endl "\n"
#define IOS cin.tie(0);cout.tie(0);ios::sync_with_stdio(0);
using namespace std;
const int mod = 1e9+7;
int MSB(unsigned x){ //most significant bit-read IEEE 754
union { double a; int64_t b; };
a = x;
return (b >> 20) - 1023;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
ll bpow(ll a,ll b){ll s=1;while(b){if(b&1)s*=a;a*=a;b>>=1;}return s;}
ll bmpow(ll a,ll b){ll s=1;while(b){if(b&1)s*=a,s%=mod;a*=a;a%=mod;b>>=1;}return s;}
const int N = 1e6+13;
int a[N];
void solve(){
int n,W;cin>>n>>W;
multiset<int> g;
for(int i=0;i<n;i++)cin>>a[i];
sort(a,a+n,greater<int>());
for(int i=0;i<n;i++){
g.insert(W);
}
for(int i=0;i<n;i++){
int x = a[i];
int y = *g.lower_bound(x);
//cout << x << " " << y << endl;
auto it = g.find(y);
if(it!=g.end())g.erase(it);
g.insert(y-x);
}
int c = g.count(W);
// for(auto x:g)cout<<x<<" ";cout<<endl;
cout << n-c << endl;
}
int main(){
IOS;
int t;
cin>>t;
while(t--)solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<string, string> mp1, mp2;
map<string, string>::iterator it;
while (n--) {
string s1, s2;
cin >> s1 >> s2;
if (mp2.find(s1) == mp2.end()) {
mp1[s1] = s2;
mp2[s2] = s1;
} else {
string s3 = mp2[s1];
mp1[s3] = s2;
mp2[s2] = s3;
}
}
cout << mp1.size() << endl;
for (it = mp1.begin(); it != mp1.end(); it++) {
cout << it->first << " " << it->second << endl;
}
}
| 2 |
#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cstring>
#include<cstdio>
//#include<bits/stdc++.h>
using namespace std;
void work(){
int n,k;
cin>>n>>k;
int x=0;
for(int i=0;i<n;i++){
if(i==0)x=0;
else x=(i^(i-1));
printf("%d\n",x);
fflush(stdout);
int f;
cin>>f;if(f==1)break;
}
fflush(stdout);
return ;
}
int main() {
int t;cin>>t;
while(t--)work();
return 0;
}
//x^2 2^3 | 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
long long n;
cin >> n;
long long a[2][2] = {{3, 1}, {1, 3}};
long long r[2][2];
long long t[2][2];
r[0][0] = r[1][1] = 1;
r[1][0] = r[0][1] = 0;
while (n) {
if (n & 1) {
memset(t, 0, sizeof(t));
for (int i = 0; i < (2); i++)
for (int j = 0; j < (2); j++)
for (int k = 0; k < (2); k++) {
t[i][j] = (t[i][j] + r[i][k] * a[k][j]) % mod;
}
memcpy(r, t, sizeof(r));
}
n /= 2;
memset(t, 0, sizeof(t));
for (int i = 0; i < (2); i++)
for (int j = 0; j < (2); j++)
for (int k = 0; k < (2); k++) {
t[i][j] = (t[i][j] + a[i][k] * a[k][j]) % mod;
}
memcpy(a, t, sizeof(a));
}
cout << r[0][0] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int numeros[n + 1];
for (int i = 0; i < n; i++) {
int a;
cin >> a;
numeros[i] = a;
}
sort(numeros, numeros + n);
set<int> largo;
for (int i = 0; i < n; ++i) {
int l, m;
l = (abs(numeros[i] % k));
m = largo.count(numeros[i] / k);
if ((l > 0) || (m == 0)) {
int a;
a = numeros[i];
largo.insert(a);
}
}
cout << largo.size();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long tt;
cin >> tt;
while (tt--) {
long long n, k;
cin >> n;
vector<long long> a(n + 1);
map<long long, vector<long long>> mp;
map<long long, set<long long>> ans;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
mp[a[i]].push_back(i);
}
for (auto it : mp) {
long long maxx = it.second[0];
for (long long i = 1; i < it.second.size(); ++i) {
long long diff = it.second[i] - it.second[i - 1];
maxx = max(maxx, diff);
}
long long diff = n - it.second.back() + 1;
maxx = max(maxx, diff);
ans[maxx].insert(it.first);
}
long long minn = LLONG_MAX;
for (long long i = 1; i <= n; ++i) {
if (ans[i].empty()) {
if (minn == LLONG_MAX)
cout << -1;
else
cout << minn;
} else {
minn = min(minn, *(ans[i].begin()));
cout << minn;
}
cout << " ";
}
cout << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 86;
long long x[MAXN], c[MAXN];
int main() {
int n, q;
int L, R;
long long tot = 0;
cin >> n >> q;
for (int i = 1; i <= n; ++i) cin >> x[i];
for (int i = 0; i < q; ++i) cin >> L >> R, --c[L - 1], ++c[R];
for (int i = n - 1; i > 0; --i) c[i] += c[i + 1];
sort(x + 1, x + n + 1);
sort(c + 1, c + n + 1);
for (int i = 1; i <= n; ++i) tot += c[i] * x[i];
cout << tot << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const inf = 1000 * 1000 * 1000;
long long const inf64 = 1ll * inf * inf;
int const K = 300005;
int const N = 1005;
int n, m, k;
int mat[N][N];
struct picture {
int color;
int li, lj, ri, rj;
void read() {
char type;
scanf("%d %d %d %d %c", &li, &lj, &ri, &rj, &type);
color = type - 'a';
}
} p[K];
int diff[K];
long long total_diff = 0;
int d[N][N];
inline int get_sum(int li, int lj, int ri, int rj) {
return d[ri][rj] - d[li - 1][rj] - d[ri][lj - 1] + d[li - 1][lj - 1];
}
int cnt[N][N];
int cnt_col[N][N];
long long sum_col[N][N];
long long cur_diff[N][N];
long long sum_diff[N][N];
long long sum_cnt_col[N][N];
long long tmp[K];
inline long long get_sum_diff(int li, int lj, int ri, int rj) {
return sum_diff[ri][rj] - sum_diff[li - 1][rj] - sum_diff[ri][lj - 1] +
sum_diff[li - 1][lj - 1];
}
inline long long get_sum_col(int li, int lj, int ri, int rj) {
return sum_col[ri][rj] - sum_col[li - 1][rj] - sum_col[ri][lj - 1] +
sum_col[li - 1][lj - 1];
}
inline long long get_sum_cnt_col(int li, int lj, int ri, int rj) {
return sum_cnt_col[ri][rj] - sum_cnt_col[li - 1][rj] -
sum_cnt_col[ri][lj - 1] + sum_cnt_col[li - 1][lj - 1];
}
void build() {
for (int i = 1; i <= k; i++) {
cnt[p[i].ri][p[i].rj]++;
cnt[p[i].li - 1][p[i].rj]--;
cnt[p[i].ri][p[i].lj - 1]--;
cnt[p[i].li - 1][p[i].lj - 1]++;
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
cnt[i - 1][j] += cnt[i][j];
cnt[i][j - 1] += cnt[i][j];
cnt[i - 1][j - 1] -= cnt[i][j];
}
}
for (int c = 0; c < 26; c++) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
cnt_col[i][j] = 0;
}
}
for (int i = 1; i <= k; i++) {
if (p[i].color != c) continue;
cnt_col[p[i].ri][p[i].rj]++;
cnt_col[p[i].li - 1][p[i].rj]--;
cnt_col[p[i].ri][p[i].lj - 1]--;
cnt_col[p[i].li - 1][p[i].lj - 1]++;
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
cnt_col[i - 1][j] += cnt_col[i][j];
cnt_col[i][j - 1] += cnt_col[i][j];
cnt_col[i - 1][j - 1] -= cnt_col[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cur_diff[i][j] += 1ll * abs(mat[i][j] - c) * cnt_col[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
sum_col[i][j] = (mat[i][j] == c) * cnt[i][j];
sum_col[i][j] +=
sum_col[i - 1][j] + sum_col[i][j - 1] - sum_col[i - 1][j - 1];
sum_cnt_col[i][j] = sum_cnt_col[i - 1][j] + sum_cnt_col[i][j - 1] -
sum_cnt_col[i - 1][j - 1];
sum_cnt_col[i][j] += cnt_col[i][j];
}
}
for (int i = 1; i <= k; i++) {
tmp[i] -= 1ll * get_sum_col(p[i].li, p[i].lj, p[i].ri, p[i].rj) *
abs(c - p[i].color);
tmp[i] += 1ll * get_sum_cnt_col(p[i].li, p[i].lj, p[i].ri, p[i].rj) *
abs(c - p[i].color);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
sum_diff[i][j] = sum_diff[i - 1][j] + sum_diff[i][j - 1] -
sum_diff[i - 1][j - 1] + cur_diff[i][j];
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
if (k == 1) {
puts("0");
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char c;
scanf(" %c", &c);
mat[i][j] = c - 'a';
}
}
for (int i = 1; i <= k; i++) {
p[i].read();
}
for (int c = 0; c < 26; c++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
d[i][j] =
d[i - 1][j] + d[i][j - 1] - d[i - 1][j - 1] + (mat[i][j] == c);
}
}
for (int i = 1; i <= k; i++) {
diff[i] +=
abs(c - p[i].color) * get_sum(p[i].li, p[i].lj, p[i].ri, p[i].rj);
}
}
for (int i = 1; i <= k; i++) {
total_diff += diff[i];
}
long long res = inf64;
build();
for (int i = 1; i <= k; i++) {
tmp[i] += total_diff - diff[i] + 1ll * diff[i] * (k - 1) + diff[i];
}
for (int i = 1; i <= k; i++) {
tmp[i] -= (get_sum_diff(p[i].li, p[i].lj, p[i].ri, p[i].rj) - diff[i]);
}
for (int i = 1; i <= k; i++) {
res = min(res, tmp[i]);
}
cout << res << "\n";
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int A,B,C,D;cin>>A>>B>>C>>D;
for(int i=0;i<D-B;i++)cout<<'U';
for(int i=0;i<C-A;i++)cout<<'R';
for(int i=0;i<D-B;i++)cout<<'D';
for(int i=0;i<C-A;i++)cout<<'L';
cout<<'L';
for(int i=0;i<D-B+1;i++)cout<<'U';
for(int i=0;i<C-A+1;i++)cout<<'R';
cout<<'D';
cout<<'R';
for(int i=0;i<D-B+1;i++)cout<<'D';
for(int i=0;i<C-A+1;i++)cout<<'L';
cout<<'U'<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
(ios_base::sync_with_stdio(false), cin.tie(NULL));
;
int t, n, x;
cin >> t;
while (t--) {
cin >> n >> x;
int c = 2, ans = 1;
while (c < n) {
c += x;
ans++;
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string dtob(long long int n) {
string r = "";
long long int t = n;
while (n > 0) {
r = to_string(n % 2) + r;
n /= 2;
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, q;
cin >> n >> q;
map<long long int, long long int> m;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
m[x] += 1;
}
vector<pair<long long int, long long int> > v1;
map<long long int, long long int>::iterator itr;
for (itr = m.begin(); itr != m.end(); itr++)
v1.insert(v1.begin(), make_pair(itr->first, itr->second));
for (long long int i = 0; i < q; i++) {
long long int x;
cin >> x;
long long int ind = 0, res = 0;
vector<pair<long long int, long long int> > v = v1;
while (ind < v.size() and x > 0) {
if (x <= v[ind].first * v[ind].second) {
long long int need = x / v[ind].first;
res += need;
x -= need * v[ind].first;
v[ind].second -= need;
} else {
res += v[ind].second;
x -= v[ind].first * v[ind].second;
v[ind].second = 0;
}
ind += 1;
}
if (x == 0)
cout << res << endl;
else
cout << "-1" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v, v2, v3, v4;
int main() {
long long ar[102] = {0}, arb[102] = {0};
long long int i = 0, j, temp = 0, c, d, n, m, k, flag = 0, mi2 = 0, sum = 0,
a, b, cur, ma = 0, ans = 0;
float re;
vector<pair<long long, long long> > vp, vp2;
string st;
cin >> st;
v.push_back(-1);
for (i = 0; i < st.size(); i++) {
if (st[i] == 'A' || st[i] == 'I' || st[i] == 'O' || st[i] == 'E' ||
st[i] == 'U' || st[i] == 'Y') {
if (st.size() == 1) {
cout << 1;
return 0;
}
v.push_back(i);
}
}
v.push_back(st.size());
for (i = 1; i < v.size(); i++) {
ma = v[i] - v[i - 1];
if (ma > flag) {
flag = ma;
}
}
cout << flag;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int count = 0, count2 = 0;
int i, j, k = -1;
cin >> n;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
if (a[i] == 1) {
k = i;
break;
}
}
if (k == -1) {
cout << "0";
return 0;
}
for (i = k; i < n;) {
if (a[i] == 1) {
count++;
i++;
} else {
for (j = i;; j++) {
if (a[j] == 1)
break;
else
count2++;
}
if (count2 == 1) {
i++;
count++;
count2 = 0;
} else {
i += count2;
count2 = 0;
}
}
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int a[100009];
int S[100009];
struct sLine {
int K, B;
int L, R;
} lines[2000009];
int linesCnt;
struct sTree {
int l, r;
sLine* arr;
int pl, pr;
int cnt;
} tree[200009];
int treeSize;
int BuildTree(int l, int r) {
int cur = treeSize++;
tree[cur].l = l;
tree[cur].r = r;
if (l < r) {
tree[cur].pl = BuildTree(l, (l + r) / 2);
tree[cur].pr = BuildTree((l + r) / 2 + 1, r);
tree[cur].arr = &lines[linesCnt + 1];
int i = 0, j = 0;
int lCnt = tree[tree[cur].pl].r - tree[tree[cur].pl].l + 1;
int rCnt = tree[tree[cur].pr].r - tree[tree[cur].pr].l + 1;
for (int k = 0; k < r - l + 1; k++) {
if (i < lCnt &&
(j >= rCnt ||
(tree[tree[cur].pl].arr[i].K > tree[tree[cur].pr].arr[j].K ||
(tree[tree[cur].pl].arr[i].K == tree[tree[cur].pr].arr[j].K &&
tree[tree[cur].pl].arr[i].B < tree[tree[cur].pr].arr[j].B))))
tree[cur].arr[k] = tree[tree[cur].pl].arr[i++];
else
tree[cur].arr[k] = tree[tree[cur].pr].arr[j++];
}
linesCnt += lCnt + rCnt;
} else {
tree[cur].arr = &lines[l];
}
return cur;
}
void BuildCH(int cur) {
int j = 1;
for (int k = 1; k < tree[cur].r - tree[cur].l + 1; k++) {
if (tree[cur].arr[k].K == tree[cur].arr[k - 1].K) continue;
int intersect = -1;
while (j) {
intersect = (tree[cur].arr[j - 1].B - tree[cur].arr[k].B) /
(tree[cur].arr[k].K - tree[cur].arr[j - 1].K);
if (intersect >= tree[cur].arr[j - 1].L) break;
j--;
intersect = -1;
}
if (j) {
tree[cur].arr[j - 1].R = intersect;
}
tree[cur].arr[j] = tree[cur].arr[k];
tree[cur].arr[j].L = intersect + 1;
j++;
}
tree[cur].cnt = j;
if (tree[cur].l < tree[cur].r) {
BuildCH(tree[cur].pl);
BuildCH(tree[cur].pr);
}
}
int Find(int X, int cur) {
int l = 0, r = tree[cur].cnt - 1;
while (l <= r) {
int m = (l + r) / 2;
if (tree[cur].arr[m].L <= X && X <= tree[cur].arr[m].R)
return tree[cur].arr[m].K * X + tree[cur].arr[m].B;
if (X < tree[cur].arr[m].L)
r = m - 1;
else
l = m + 1;
}
}
int calcAns(int l, int r, int cur) {
if (l <= tree[cur].l && r >= tree[cur].r) return Find(l - 1, cur);
int ans = 100000000;
if (l <= tree[tree[cur].pl].r && tree[tree[cur].pl].l <= r) {
int tmp = calcAns(l, r, tree[cur].pl);
if (ans > tmp) ans = tmp;
}
if (l <= tree[tree[cur].pr].r && tree[tree[cur].pr].l <= r) {
int tmp = calcAns(l, r, tree[cur].pr);
if (ans > tmp) ans = tmp;
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
S[i] = S[i - 1] + a[i];
linesCnt++;
lines[linesCnt].K = -a[i];
lines[linesCnt].B = a[i] * i - S[i];
lines[linesCnt].L = 0;
lines[linesCnt].R = 100000000;
}
int root = BuildTree(1, n);
BuildCH(root);
int m;
scanf("%d", &m);
while (m--) {
int x, y;
scanf("%d %d", &x, &y);
printf("%d\n", S[y] + calcAns(y - x + 1, y, root));
}
}
| 5 |
#include <iostream>
using namespace std;
int main(){
int S, W;
cin >> S >> W;
cout << (S > W ? "safe" : "unsafe");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 600010;
int mem[MAXN], lan[MAXN], accept[MAXN], like[MAXN], b[MAXN];
int cnt[MAXN];
int n, m, tmp, t;
void discrete() {
for (int i = 1; i <= tmp; i++) b[i] = lan[i];
sort(b + 1, b + tmp + 1);
t = unique(b + 1, b + tmp + 1) - b - 1;
}
int query(int x) { return lower_bound(b + 1, b + 1 + t, x) - b; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> mem[i];
lan[++tmp] = mem[i];
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> like[i];
lan[++tmp] = like[i];
}
for (int i = 1; i <= m; i++) {
cin >> accept[i];
lan[++tmp] = accept[i];
}
discrete();
for (int i = 1; i <= n; i++) cnt[query(mem[i])]++;
int ans = 1, max1 = 0, max2 = 0;
for (int i = 1; i <= m; i++) {
int x = cnt[query(like[i])], y = cnt[query(accept[i])];
if (x > max1 || x == max1 && y > max2) {
ans = i;
max1 = x;
max2 = y;
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ans[2000][2000];
int main() {
long long n, k, d, f = 0;
cin >> n >> k >> d;
long long x = 1;
for (int i = 1; i <= d; i++) {
x *= k;
if (x >= n) {
f = 1;
break;
}
}
if (!f) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
int l = i, j = 0;
while (l > 0) {
ans[j++][i] = l % k;
l /= k;
}
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < n; j++) cout << ans[i][j] + 1 << " ";
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long B[4001], c[4001][4001], n, ans = 0;
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 0; i <= n; i++) c[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007;
B[1] = 1;
B[0] = 1;
for (int i = 2; i <= n; i++)
for (int k = 0; k < i; k++)
B[i] = (B[i] + 1LL * c[i - 1][k] * B[k] % 1000000007) % 1000000007;
for (int i = 1; i <= n; i++)
ans = (ans + 1LL * c[n][i] * B[n - i] % 1000000007) % 1000000007;
printf("%d\n", ans);
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int n;
char s[1000100];
char t[1000100];
queue<int>q;
int main()
{
scanf("%d",&n);
scanf("%s",s+1);
scanf("%s",t+1);
int ans=0;
for(int i=1;i<=n;++i)
if(s[i]!=t[i]){ans=1;break;}
if(!ans)
{
puts("0");
return 0;
}
for(int up=n,dn=n;dn;--dn)
{
while(t[dn-1]==t[dn])dn--;
up=min(up,dn);
while(s[up]!=t[dn]&&up)up--;
if(!up)
{
puts("-1");
return 0;
}
while(!q.empty())
{
if(q.front()-q.size()+1>dn)q.pop();
else break;
}
if(up!=dn)q.push(up);
ans=max(ans,(int)q.size()+1);
}
printf("%d\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
long long int n, a, b, i, t;
scanf("%lld %lld %lld", &n, &a, &b);
t = n / a + 1;
for (i = 0; i < t; i++) {
if ((n - (a * i)) % b == 0 && n - (a * i) >= 0) {
printf("YES\n%lld %lld", i, (n - (a * i)) / b);
return 0;
}
}
printf("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, msize = 0, head = 1, tail = 0;
long long t[300010] = {0}, w[300010] = {0}, mheap[300010];
int mqueue[300010];
void insert_heap(long long key) {
mheap[++msize] = key;
long long tmp = mheap[msize];
int cur = msize, fc = msize / 2;
while (cur > 1) {
if (mheap[fc] <= tmp) break;
mheap[cur] = mheap[fc];
cur = fc;
fc = cur / 2;
}
mheap[cur] = tmp;
}
void del_heap(int x) {
mheap[x] = mheap[msize--];
int cur = x, sc = x * 2;
long long tmp = mheap[cur];
while (sc <= msize) {
if (sc < msize && mheap[sc] > mheap[sc + 1]) sc++;
if (tmp <= mheap[sc]) break;
mheap[cur] = mheap[sc];
cur = sc;
sc *= 2;
}
mheap[cur] = tmp;
}
bool cmp(int x, int y) { return t[x] > t[y]; }
int work() {
sort(mqueue + 1, mqueue + tail + 1, cmp);
int ans = msize + 1;
long long tmp = mheap[1];
while (t[1] >= tmp + 1 && msize > 0) {
t[1] -= (tmp + 1);
del_heap(1);
while (t[mqueue[head]] > t[1] && head <= tail) {
insert_heap(w[mqueue[head]] - t[mqueue[head]]);
head++;
}
ans = min(ans, msize + 1);
tmp = mheap[1];
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> t[i] >> w[i];
if (i > 1 && t[i] <= t[1]) {
mqueue[++tail] = i;
}
if (i > 1 && t[i] > t[1]) {
insert_heap(w[i] - t[i]);
}
}
printf("%d\n", work());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100010];
bool vis[100010];
double len[100010];
bool chk[100010];
void dfs(int s) {
bool f = 0;
for (int i = 0; i < g[s].size(); i++) {
int j = g[s][i];
if (!vis[j]) f = 1;
}
if (!f) {
chk[s] = 1;
return;
}
for (int i = 0; i < g[s].size(); i++) {
int j = g[s][i];
if (!vis[j]) {
vis[j] = 1;
len[j] = len[s] + 1;
dfs(j);
}
}
double sum = 0, ct = 0;
bool ff = 0;
for (int i = 0; i < g[s].size(); i++) {
int j = g[s][i];
if (chk[j]) {
sum += len[j];
ff = 1;
ct++;
}
}
if (ff) {
chk[s] = 1;
len[s] = sum / ct;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
memset(vis, 0, sizeof(vis));
vis[1] = 1;
dfs(1);
printf("%.15f", len[1]);
return (0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
string s;
cin>>n>>s;
if(s.substr(0,n/2)==s.substr(n/2,n)&&n%2==0) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e6 + 3;
long long inf = 1e18;
double eps = 1e-2;
ifstream in("input.txt");
ofstream out("output.txt");
int main() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<vector<int>> links(n + 3, vector<int>(26, n + 1));
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
links[i][j] = links[i + 1][j];
}
links[i][s[i] - 'a'] = i;
}
string s1, s2, s3;
vector<vector<vector<int>>> dp(
251, vector<vector<int>>(251, vector<int>(251, n + 2)));
dp[0][0][0] = 0;
int a = 0, b = 0, c = 0;
for (int w = 0; w < q; w++) {
char ch;
cin >> ch;
int t;
cin >> t;
if (ch == '+') {
cin >> ch;
if (t == 1) {
s1.push_back(ch);
a++;
for (int i = 0; i <= b; i++) {
for (int j = 0; j <= c; j++) {
dp[a][i][j] = links[dp[a - 1][i][j]][ch - 'a'] + 1;
if (i > 0)
dp[a][i][j] =
min(dp[a][i][j], links[dp[a][i - 1][j]][s2[i - 1] - 'a'] + 1);
if (j > 0)
dp[a][i][j] =
min(dp[a][i][j], links[dp[a][i][j - 1]][s3[j - 1] - 'a'] + 1);
}
}
}
if (t == 2) {
s2.push_back(ch);
b++;
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= c; j++) {
dp[i][b][j] = links[dp[i][b - 1][j]][ch - 'a'] + 1;
if (i > 0)
dp[i][b][j] =
min(dp[i][b][j], links[dp[i - 1][b][j]][s1[i - 1] - 'a'] + 1);
if (j > 0)
dp[i][b][j] =
min(dp[i][b][j], links[dp[i][b][j - 1]][s3[j - 1] - 'a'] + 1);
}
}
}
if (t == 3) {
s3.push_back(ch);
c++;
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
dp[i][j][c] = links[dp[i][j][c - 1]][ch - 'a'] + 1;
if (i > 0)
dp[i][j][c] =
min(dp[i][j][c], links[dp[i - 1][j][c]][s1[i - 1] - 'a'] + 1);
if (j > 0)
dp[i][j][c] =
min(dp[i][j][c], links[dp[i][j - 1][c]][s2[j - 1] - 'a'] + 1);
}
}
}
} else {
if (t == 1) {
for (int i = 0; i <= b; i++) {
for (int j = 0; j <= c; j++) {
dp[a][i][j] = n + 2;
}
}
s1.pop_back();
a--;
}
if (t == 2) {
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= c; j++) {
dp[i][b][j] = n + 2;
}
}
s2.pop_back();
b--;
}
if (t == 3) {
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
dp[i][j][c] = n + 2;
}
}
s3.pop_back();
c--;
}
}
if (dp[a][b][c] != n + 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, sgn = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') sgn = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48);
return x * sgn;
}
const int N = 3e5 + 10;
int h[N], cnt, deg[N], m, n, f[N], u[N], v[N];
bool cannot[N];
struct edge {
int v, nxt;
} e[N << 1];
void link(int x, int y) {
e[++cnt] = (edge){y, h[x]};
h[x] = cnt;
deg[y]++;
}
void check(int x, int y, int w) {
for (int i = h[y], t; i; i = e[i].nxt) {
t = e[i].v;
if (deg[t] == 1) return cannot[x] = 1, void();
}
f[x] += w;
}
void topsort() {
int tot = 0;
queue<int> q;
for (int i = 1; i <= n; i++)
if (!deg[i]) q.push(i), tot++;
while (q.size()) {
int x = q.front();
q.pop();
if (!q.size()) f[x] += n - tot;
if (q.size() == 1) check(x, q.front(), n - tot);
for (int i = h[x], y; i; i = e[i].nxt) {
y = e[i].v;
deg[y]--;
if (!deg[y]) q.push(y), tot++;
}
}
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
u[i] = read(), v[i] = read();
link(u[i], v[i]);
}
topsort();
memset(h, 0, sizeof(h));
memset(deg, 0, sizeof(deg));
cnt = 0;
for (int i = 1; i <= m; i++) link(v[i], u[i]);
topsort();
int ans = 0;
for (int i = 1; i <= n; i++)
if (!cannot[i] && f[i] >= n - 2) ans++;
printf("%d\n", ans);
return 0;
}
| 6 |
#include <cstdio>
#include <cstring>
#include <algorithm>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
#define rep(i,a) for(int i=lst[a];i;i=nxt[i])
#define mp(a,b) make_pair(a,b)
using namespace std;
typedef pair<int,int> pii;
#define fi first
#define se second
int read() {
char ch;
for(ch=getchar();ch<'0'||ch>'9';ch=getchar());
int x=ch-'0';
for(ch=getchar();ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x;
}
const int N=2e3+5;
int t[N<<1],nxt[N<<1],lst[N],l;
void add(int x,int y) {t[++l]=y;nxt[l]=lst[x];lst[x]=l;}
int n,m,deg[N],fa[N][11],dep[N],c[N],u[N],v[N],p[N];
bool col[N],ban[N];
pii now[N];
void dfs(int x,int y) {
dep[x]=dep[y]+1;fa[x][0]=y;
rep(i,x) if (t[i]!=y) dfs(t[i],x);
}
int lca(int x,int y) {
if (dep[x]<dep[y]) swap(x,y);
fd(j,10,0) if (dep[fa[x][j]]>dep[y]) x=fa[x][j];
x=dep[x]==dep[y]?x:fa[x][0];
fd(j,10,0) if (fa[x][j]!=fa[y][j]) x=fa[x][j],y=fa[y][j];
return x==y?x:fa[x][0];
}
void calc(int x,int y) {rep(i,x) if (t[i]!=y) calc(t[i],x),c[x]+=c[t[i]];}
int main() {
n=read();m=read();
fo(i,1,n-1) {
int x=read(),y=read();
add(x,y);add(y,x);
deg[x]++;deg[y]++;
}
dfs(1,0);
fo(j,1,10) fo(i,1,n) fa[i][j]=fa[fa[i][j-1]][j-1];
fo(i,1,m) {
u[i]=read(),v[i]=read();
int z=lca(u[i],v[i]);
c[u[i]]++;c[v[i]]++;c[z]-=2;
}
calc(1,0);
fo(i,1,m) now[i]=mp(u[i],v[i]);
int ans=0;
fo(i,1,n) ans+=min(c[i],2);
printf("%d\n",ans);
fo(tim,1,n-1) {
int x,y;
fo(i,2,n) if (!ban[i]&°[i]==1) {x=i;break;}
rep(j,x) if (!ban[t[j]]) y=t[j];
ban[x]=1;deg[y]--;
int p1=0,p2=0;
fo(i,1,m)
if ((now[i].fi==x)^(now[i].se==x)) {
if (!p1) p1=i;
else if (!p2) p2=i;
}
if (!p1) continue;
if (!p2) {
if (now[p1].fi==x) now[p1].fi=y;
else now[p1].se=y;
continue;
}
if (now[p1].fi==x) {
if (now[p2].fi==x) {
now[p1].fi=now[p2].se;
col[p2]^=1;
} else now[p1].fi=now[p2].fi;
} else {
if (now[p2].se==x) {
now[p1].se=now[p2].fi;
col[p2]^=1;
} else now[p1].se=now[p2].se;
}
p[p2]=p1;now[p2].fi=now[p2].se;
fo(i,1,m) {
if (now[i].fi==x) now[i].fi=y;
if (now[i].se==x) now[i].se=y;
}
}
fo(i,1,m) if (p[i]) col[i]^=col[p[i]];
fo(i,1,m) {
if (col[i]) swap(u[i],v[i]);
printf("%d %d\n",u[i],v[i]);
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct BIT {
int n;
vector<int> v;
BIT(int n) : v(n+1) {
this->n = n;
}
void add(int a, int x) {
for (int i = a; i <= n; i += i & -i)
v[i] += x;
}
int sum(int a) {
int res = 0;
for (int i = a; i > 0; i -= i & -i)
res += v[i];
return res;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin >> N;
vector<int> a(N);
int maxA = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
maxA = max(maxA, a[i]);
}
long long ml = (1LL + N) * N / 2;
int low = 0, high = maxA+1;
while (high - low > 1) {
int mid = (low + high) / 2;
BIT bit(N*2+2);
int cs = N+1;
long long res = 0;
bit.add(cs, 1);
for (int i = 0; i < N; i++) {
cs += a[i] < mid ? -1 : 1;
res += bit.sum(cs);
bit.add(cs, 1);
}
if (res >= (ml+1)/2)
low = mid;
else
high = mid;
}
cout << low << "\n";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char in[10];
int res = 10;
void dfs(int sum1, int sum2, int nm, int cur) {
if (cur == 6) {
if (sum1 == sum2) res = min(res, nm);
return;
}
for (int i = 0; i < 10; i++)
if (cur < 3)
dfs(sum1 + i, sum2, nm + (i != in[cur] - '0'), cur + 1);
else
dfs(sum1, sum2 + i, nm + (i != in[cur] - '0'), cur + 1);
}
int main() {
ios_base::sync_with_stdio(0);
for (int i = 0; i < 6; i++) {
cin >> in[i];
}
dfs(0, 0, 0, 0);
cout << res << "\n";
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;cin>>a>>b>>c;
int x=7*a+b,cnt=0;
cnt+=c/x*7;int y=c%x;if(y>0)cnt+=min((y-1+a)/a,7);
cout<<cnt<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> m;
long long a[10004];
long long f(long long a, long long b) {
m[a]--;
m[b]--;
vector<long long> v;
v.push_back(a);
v.push_back(b);
long long x = b;
long long y = a + b;
while (m[y] != 0) {
m[y]--;
v.push_back(y);
y = x + y;
x = y - x;
}
for (long long i = 0; i < v.size(); i++) m[v[i]]++;
return v.size();
}
signed main() {
long long n, ans;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
ans = -1;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (i != j) {
if (a[i] == a[j] && !a[i])
ans = max(ans, m[0]);
else {
ans = max(ans, f(a[i], a[j]));
}
}
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int q;
scanf("%d", &q);
while (q--) {
long long a, b, c;
scanf("%lld%lld%lld", &a, &b, &c);
printf("%lld\n", (a + b + c) / 2);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long mod = 1e9 + 7;
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T> v) {
os << "(" << v.first << ", " << v.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T> v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<vector<T>> v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
struct point {
long long id, x, y, z;
bool operator<(const point& right) const {
if (x == right.x) {
if (y == right.y) {
return z < right.z;
} else {
return y < right.y;
}
} else {
return x < right.x;
}
}
};
long long dist(point& p1, point& p2) {
long long dx = abs(p1.x - p2.x);
long long dy = abs(p1.y - p2.y);
long long dz = abs(p1.z - p2.z);
return dx + dy + dz;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n;
cin >> n;
vector<point> P;
vector<point> Q;
vector<point> R;
for (int i = 0; i < (int)n; ++i) {
long long x, y, z;
cin >> x >> y >> z;
point p = {i, x, y, z};
P.push_back(p);
}
sort(P.begin(), P.end());
for (int i = 0; i < (int)n; ++i) {
int j = i;
while (j < n && P[i].x == P[j].x && P[i].y == P[j].y) j++;
int len = j - i;
for (int k = 0; k < (int)len / 2; ++k) {
cout << P[i + 2 * k].id + 1 << " " << P[i + 2 * k + 1].id + 1 << endl;
}
if (len % 2 == 1) Q.push_back(P[i + len - 1]);
i = j - 1;
}
sort(Q.begin(), Q.end());
long long m = Q.size();
for (int i = 0; i < (int)m; ++i) {
int j = i;
while (j < m && Q[i].x == Q[j].x) j++;
int len = j - i;
for (int k = 0; k < (int)len / 2; ++k) {
cout << Q[i + 2 * k].id + 1 << " " << Q[i + 2 * k + 1].id + 1 << endl;
}
if (len % 2 == 1) R.push_back(Q[i + len - 1]);
i = j - 1;
}
for (int i = 0; i < (int)R.size() / 2; ++i) {
cout << R[2 * i].id + 1 << " " << R[2 * i + 1].id + 1 << endl;
}
return 0;
}
| 3 |
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
using namespace std;
struct Node {
double x, y, r;
Node(double x, double y, double r) : x(x), y(y), r(r) {}
};
int n, k;
vector<int> x, y, c;
double distance(double px, double py) {
vector<double> dis(n);
for (int i = 0; i < n; ++i) {
dis[i] = c[i] * hypot(px - x[i], py - y[i]);
}
nth_element(dis.begin(), dis.begin() + k - 1, dis.end());
return dis[k - 1];
}
double distance_lb(double px, double py, double r) {
vector<double> dis(n);
for (int i = 0; i < n; ++i) {
dis[i] = c[i] * hypot(max(abs(px - x[i]) - r, 0.0), max(abs(py - y[i]) - r, 0.0));
}
nth_element(dis.begin(), dis.begin() + k - 1, dis.end());
return dis[k - 1];
}
int main() {
cin >> n >> k;
x.resize(n);
y.resize(n);
c.resize(n);
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i] >> c[i];
}
queue<Node> que;
double res = distance(0, 0);
que.emplace(0, 0, 1000);
while (!que.empty()) {
auto node = que.front();
que.pop();
for (double dx : {-0.5, 0.5}) {
for (double dy : {-0.5, 0.5}) {
double nx = node.x + dx * node.r, ny = node.y + dy * node.r, nr = node.r / 2;
double dis_lb = distance_lb(nx, ny, nr);
if (res - dis_lb > 5e-7 * max(1.0, dis_lb)) {
res = min(res, distance(nx, ny));
que.emplace(nx, ny, nr);
}
}
}
}
cout << fixed << setprecision(15) << res << endl;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.