solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int h, w, k;
cin >> h >> w >> k;
vector<string> S(h);
rep(i, h) cin >> S[i];
int ans = 1001001001;
rep(bit, (1 << h - 1)) {
int cnt_h = 0;
rep(i, h - 1) if (bit & (1 << i)) cnt_h++;
int cnt_w = 0;
vector<int> sum(cnt_h + 1, 0);
bool elf = true;
rep(i, w) {
vector<int> tmp(cnt_h + 1, 0);
int now = 0;
rep(j, h) {
if (S[j][i] == '1') tmp[now]++;
if (bit & (1 << j)) {
now++;
}
}
rep(j, cnt_h + 1) {
if (tmp[j] > k) elf = false;
if (sum[j] + tmp[j] > k) {
cnt_w++;
rep(k, cnt_h + 1) {
sum[k] = tmp[k];
}
break;
}
else {
sum[j] += tmp[j];
}
}
}
if (!elf) continue;
ans = min(ans, cnt_h + cnt_w);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
inline long long Read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
int n, r[105], fa[105];
set<int> s[105];
int fd(int x) { return fa[x] == x ? x : x = fd(fa[x]); }
void solve(int t) {
n = read();
for (int i = 1; i <= n; i++) r[i] = read(), fa[i] = i;
for (int i = 1; i <= n; i++) {
int d = read();
if (i - d >= 1) fa[fd(i - d)] = fd(i);
if (i + d <= n) fa[fd(i + d)] = fd(i);
}
for (int i = 1; i <= n; i++) s[fd(i)].insert(i);
for (int i = 1; i <= n; i++)
if (!s[fd(i)].count(r[i])) {
printf("NO");
return;
}
printf("YES");
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) solve(i);
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main() {
int n; scanf("%d",&n);
while (n--) {
int a; scanf("%d",&a);
if (a%2==0) {
if (a%3!=0 && a%5!=0) {
printf("DENIED");
return 0;
}
}
}
printf("APPROVED");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, l, r, m, a, b, c;
cin >> t;
while (t--) {
cin >> l >> r >> m;
a = -1;
for (long long i = l; i <= r; ++i) {
if (i >= m) {
long long left = i - m;
if (left <= r - l) {
a = i;
b = l;
c = left + l;
break;
}
continue;
}
long long left = m % i;
if (left <= r - l) {
a = i;
b = left + l;
c = l;
break;
}
left = (i - left);
if (left <= r - l) {
a = i;
c = left + l;
b = l;
break;
}
}
cout << a << ' ' << b << ' ' << c << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
pair<int, int> a[n];
for (size_t i = 0; i < n; i++) {
scanf("%i %i", &a[i].first, &a[i].second);
}
sort(a, a + n);
for (int i = 0, x = -1, y = -1; i < n; i++) {
if (x < a[i].first)
x = a[i].second;
else if (y < a[i].first)
y = a[i].second;
else {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chmax(T &u, const T z) {
if (u < z) {
u = z;
return true;
} else
return false;
}
int main() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < (int)(n); i++) cin >> a[i];
sort(a.begin(), a.end());
long long kotae = LLONG_MAX;
bool hantei = false;
for (int i = 0; i < 100000; i++) {
long long tmp = 1;
long long sum = 0;
for (int j = 0; j < n; j++) {
if (j > 0) tmp *= i;
if (tmp > 1e12) {
hantei = true;
break;
}
sum += abs(a[j] - tmp);
}
if (hantei) break;
kotae = min(kotae, sum);
}
cout << kotae << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int a[N], sl[N], sr[N];
int main() {
long long inf = 1e10;
int n, l, r, ql, qr;
cin >> n >> l >> r >> ql >> qr;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) sl[i] = sl[i - 1] + a[i];
for (int i = n; i >= 1; i--) sr[i] = sr[i + 1] + a[i];
long long ans = inf;
for (int nl = 0; nl <= n; nl++) {
int nr = n - nl;
long long extra = 0;
if (nl > nr)
extra = 1LL * ql * (nl - nr - 1);
else if (nr > nl)
extra = 1LL * qr * (nr - nl - 1);
long long sum = extra;
sum += 1LL * l * sl[nl] + 1LL * r * sr[nl + 1];
ans = min(sum, ans);
}
cout << ans << endl;
cin >> n;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int Mod = 998244353;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t-- > 0) {
long long int n;
cin >> n;
vector<long long int> v;
long long int i;
string s = to_string(n);
long long int z = s.size();
long long int p = z - 1;
for (i = 0; i < z; i++) {
long long int z1 = pow(10, p);
if ((s[i] - '0') != 0) {
long long int r = (s[i] - '0') * z1;
v.push_back(r);
}
p--;
}
cout << v.size() << "\n";
for (auto i : v) {
cout << i << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define inside sl<=l&&r<=sr
#define outside r<sl||sr<l
#define INF 1000000009
#define mod 1000000007
using namespace std;
typedef long long ll;
int n, m, k;
pair<int, int> engel[3003];
ll dp[3003];
ll fac[200005];
void ayar(ll& a){
a = ((a%mod)+mod)%mod;
}
ll us(ll a, ll b){
ll ans = 1;
while (b){
if (b & 1){
ans *= a;
ans %= mod;
}
a *= a;
a %= mod;
b >>= 1;
}
return ans;
}
ll get(ll a, ll b){
return (fac[a+b]*us((fac[a]*fac[b])%mod, mod-2))%mod;
}
int main(){
//freopen("stl.gir", "r", stdin);
cin >> n >> m >> k;
for (int i = 0; i < k; i++){
cin >> engel[i].first >> engel[i].second;
engel[i].first--;
engel[i].second--;
}
engel[k] = mp(0, 0);
k++;
sort(engel, engel+k);
fac[0] = 1;
for (ll i = 1; i < 200005; i++) fac[i] = (fac[i-1]*i)%mod;
for (int i = k-1; i >= 0; i--){
//cout << "(" << engel[i].first << ", " << engel[i].second << ")" << endl;
dp[i] = get(abs(engel[i].first - n+1), abs(engel[i].second - m+1));
for (int j = i+1; j < k; j++){
if (engel[j].first >= engel[i].first && engel[j].second >= engel[i].second){
dp[i] -= (dp[j]*get(abs(engel[i].first-engel[j].first), abs(engel[i].second - engel[j].second)))%mod;
ayar(dp[i]);
}
}
//cout << "dp: " << dp[i] << endl;
}
cout << dp[0] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x = x * f;
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename E>
E gcd(E a, E b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename E>
E lcm(E a, E b) {
return a * b / gcd(a, b);
}
template <typename E>
E ex_gcd(E a, E b, E &x, E &y) {
if (b == 0) {
x = 1;
y = 0;
} else {
ex_gcd(b, a % b, y, x);
y -= (a / b) * x;
}
}
template <typename E>
E quick_mul(E a, E b, E c) {
E ans = 0;
while (b) {
if (b & 1) ans = (ans + a) % c;
a = (a + a) % c;
b >>= 1;
}
return ans;
}
template <typename E>
E quick_pow(E a, E b, E c) {
E ans = 1;
while (b) {
if (b & 1) ans = ans * a % c;
a = a * a % c;
b >>= 1;
}
return ans;
}
template <typename E>
E inv1(E a, E b) {
return quick_pow(a, b - 2, b);
}
template <typename E>
E inv2(E a, E b) {
E x, y;
ex_gcd(a, b, x, y);
return (x % b + b) % b;
}
const double eps = 1.0e-5;
const int maxn = 200000 + 10;
const long long mod = 1e9 + 7;
int k;
char s1[maxn], s2[maxn], ans[maxn];
int a[maxn], b[maxn];
int sum[maxn];
int en = 0, t[maxn];
int main() {
scanf("%d", &k);
scanf("%s %s", s1 + 1, s2 + 1);
for (int i = (1); i <= (k); i++) a[i] = s1[i] - 'a', b[i] = s2[i] - 'a';
int m = 0;
for (int i = (k); i >= (1); i--) {
int cur = b[i] + a[i] + m;
if (cur > 25) {
m = cur / 26;
t[++en] = cur % 26;
} else {
t[++en] = cur;
m = 0;
}
}
if (m) t[++en] = m;
m = 0;
if (t[en] == 1) {
en--;
m = 1;
}
for (int i = (en); i >= (1); i--) {
int cur = m * 26 + t[i];
ans[i] = 'a' + (cur / 2);
m = cur % 2;
}
for (int i = (en); i >= (1); i--) printf("%c", ans[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200009];
int l[200009], r[200009], ans[200009];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
a[0] = 0;
a[n + 1] = 0;
l[0] = 0;
r[n + 1] = n + 1;
for (int i = 1; i <= n; i++) {
l[i] = i - 1;
while (a[l[i]] >= a[i]) l[i] = l[l[i]];
}
for (int i = n; i >= 1; i--) {
r[i] = i + 1;
while (a[r[i]] >= a[i]) r[i] = r[r[i]];
}
for (int i = 1; i <= n; i++) {
int ll = r[i] - l[i] - 1;
ans[ll] = max(ans[ll], a[i]);
}
for (int i = n - 1; i >= 1; i--) ans[i] = max(ans[i], ans[i + 1]);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string sortString(string& str) {
sort(str.begin(), str.end());
return str;
}
string operator*(const string& s, unsigned int n) {
stringstream out;
while (n--) out << s;
return out.str();
}
int knapSack(int value[], int weight[], int w, int n) {
if (w == 0 || n == 0) {
return 0;
}
if (weight[n - 1] <= w) {
return max(value[n - 1] + knapSack(value, weight, w - weight[n - 1], n - 1),
knapSack(value, weight, w, n - 1));
} else if (weight[n - 1] > w)
return knapSack(value, weight, w, n - 1);
}
int ribbon(int n, int a, int b, int c) {
int d = min(min(a, b), c);
if (n == d) return 0;
}
void SieveOfEratosthenes(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int i = 2; i < n + 1; i++) {
if (prime[i] == true) {
cout << i << endl;
}
}
}
bool length_con(int n, int m, int k) {
int d = 0;
int sum = 0;
while (n > 0) {
int c = n % 10;
sum += c;
d++;
n = n / 10;
}
if (sum == m && d == k) {
return true;
} else {
return false;
}
}
int min_arr(int arr[], int n) {
int minim = 31;
for (int i = 0; i < n; i++) {
if (arr[i] < minim) {
minim = i;
}
}
return minim;
}
int max_arr(int arr[], int n) {
int maxi = 0;
for (int i = 0; i < n; i++) {
if (arr[i] > maxi) {
maxi = i;
}
}
return maxi;
}
int sum(int arr[], int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += arr[i];
}
return sum;
}
void sortEst() {
int c, t;
cin >> c >> t;
double lo = 1;
double hi = 2000000000;
while (hi - lo > 0) {
double mid = (lo + hi) / 2;
double time = c * mid * log2(mid);
if (t == time) {
cout << mid << endl;
break;
} else if (t > time) {
lo = mid;
} else if (t < time) {
hi = mid;
}
}
}
int ans[1000];
int tiles(int n) {
ans[1] = 1;
ans[2] = 2;
for (int i = 3; i <= n; i++) {
ans[i] = ans[i - 1] + ans[i - 2];
}
return ans[n];
}
int supw(int n, int arr[], int m) {
if (m == n - 1) return arr[m];
if (m == n - 2) return arr[m];
if (m == n - 3) return arr[m];
return min(arr[m] + supw(n, arr, m + 1),
min(arr[m] + supw(n, arr, m + 2), arr[m] + supw(n, arr, m + 3)));
}
bool isSubsetSum(int set[], int n, int sum) {
bool subset[n + 1][sum + 1];
for (int i = 0; i <= n; i++) subset[i][0] = true;
for (int i = 1; i <= sum; i++) subset[0][i] = false;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= sum; j++) {
if (j < set[i - 1]) subset[i][j] = subset[i - 1][j];
if (j >= set[i - 1])
subset[i][j] = subset[i - 1][j] || subset[i - 1][j - set[i - 1]];
}
}
return subset[n][sum];
}
bool equal_sum_partition(int arr[], int n, int sum) {
if (n == 0 and sum != 0) return false;
if (sum == 0) return true;
if (arr[n - 1] > sum) return equal_sum_partition(arr, n - 1, sum);
return equal_sum_partition(arr, n - 1, sum) ||
equal_sum_partition(arr, n - 1, sum - arr[n - 1]);
}
int subset_count(int arr[], int n, int sum) {
int subset[n + 1][sum + 1];
memset(subset, 0, sizeof(subset));
for (int i = 0; i <= n; i++) subset[i][0] = 1;
for (int i = 1; i <= sum; i++) subset[0][i] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= sum; j++) {
if (j < arr[i - 1])
subset[i][j] = subset[i - 1][j];
else {
subset[i][j] = subset[i - 1][j] + subset[i - 1][j - arr[i - 1]];
}
}
}
return subset[n][sum];
}
int find_min(int arr[], int n) {
int diff = 100;
int range = accumulate(arr, arr + n, 0);
for (int i = 0; i <= range / 2; i++) {
if (isSubsetSum(arr, n, i)) {
diff = min(diff, range - 2 * i);
}
}
return diff;
}
int unbounded_knapsack(int w, int value[], int weight[], int m) {
if (m == 0 || w == 0) return 0;
if (weight[m - 1] > w)
return unbounded_knapsack(w, value, weight, m - 1);
else
return max(
value[m - 1] + unbounded_knapsack(w - value[m - 1], value, weight, m),
unbounded_knapsack(w, value, weight, m - 1));
}
int rod_cutting(int arr[], int n) {
int dp[n + 1][n + 1];
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < n + 1; j++) {
if (i == 0 || j == 0)
dp[i][j] = 0;
else if (i > j)
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = max(dp[i - 1][j], arr[i - 1] + dp[i][j - i]);
}
}
return dp[n][n];
}
int coin_change_no_of_ways(int arr[], int n, int sum) {
if (sum == 0) return 1;
if (n <= 0 && sum > 0) return 0;
if (arr[n - 1] > sum) return coin_change_no_of_ways(arr, n - 1, sum);
return coin_change_no_of_ways(arr, n - 1, sum) +
coin_change_no_of_ways(arr, n, sum - arr[n - 1]);
}
int maxSum(int arr[], int n, int k) {
int res = 0;
for (int i = 0; i < k; i++) res += arr[i];
int idx = 0;
int curr_sum = res;
for (int i = k; i < n; i++) {
curr_sum += arr[i] - arr[i - k];
if (curr_sum < res) {
idx = i;
}
res = min(res, curr_sum);
}
if (idx == 0) return 2;
return idx;
}
int fact(int n) {
if (n == 0 || n == 1) return 1;
return n * fact(n - 1);
}
int pair_cal(int n) {
if (n == 1) return 0;
return (n - 1) + pair_cal(n - 1);
}
int most_repeating(int arr[], int n) {
unordered_map<int, int> v;
for (int i = 0; i < n; i++) {
v[arr[i]] += 1;
}
int freq = -1;
int res = 0;
for (auto i : v) {
if (i.second > freq) {
freq = i.second;
res = i.first;
}
}
return res;
}
int get_smallest_divisor(int n) {
if (n % 2 == 0)
return 2;
else {
for (int i = 3; i * i <= n; i += 2) {
if (n % i == 0) return i;
}
}
return n;
}
void show_pq(priority_queue<int> pq) {
priority_queue<int> g = pq;
while (!g.empty()) {
cout << g.top() << " ";
g.pop();
}
cout << endl;
}
void pairsort(int a[], int b[], int n) {
pair<int, int> pairt[n];
for (int i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (int i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
void bin(unsigned n) {
unsigned i;
for (i = 1 << 31; i > 0; i = i / 2) (n & i) ? printf("1") : printf("0");
}
vector<pair<int, int>> find_sub_sum_0(int arr[], int n) {
unordered_map<int, vector<int>> mp;
vector<pair<int, int>> out;
int sum = 0;
for (int i = 0; i < n; i++) {
sum += arr[i];
if (sum == 0) {
out.push_back(make_pair(0, i));
}
if (mp.find(sum) != mp.end()) {
vector<int> vc = mp[sum];
for (auto it = vc.begin(); it != vc.end(); it++) {
}
}
}
return out;
}
int cnt[1000001];
int solve(int arr[], int n, int k, int z) {
int dp[n + 1];
dp[0] = 0, dp[1] = arr[0];
for (int i = 2; i < n + 1; i++) {
if (k == 0) {
dp[i] = dp[i - 1];
continue;
}
if (z == 0) {
if (k > 0) {
dp[i] = dp[i - 1] + arr[i - 1];
k--;
} else {
dp[i] = dp[i - 1];
}
} else {
dp[i] = max(dp[i - 1] + arr[i - 2], dp[i - 1] + arr[i - 1]);
if (dp[i] == dp[i - 1] + arr[i - 2]) {
z--;
}
k--;
}
}
for (int i = 0; i < n + 1; i++) {
cout << dp[i] << " ";
}
cout << endl;
return dp[n];
}
bool cmp(pair<string, int>& a, pair<string, int>& b) {
return a.second < b.second;
}
bool is_prime(int n) {
if (n == 1) {
return false;
}
int i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
int solve(long long arr[], long long n, long long sum) {
vector<long long> a;
if (sum % n) {
sum -= n;
long long cnter = 1;
a.push_back(n);
arr[n - 1] = -1;
for (long long i = 1; sum > 0; i++) {
sum -= i;
a.push_back(i);
arr[i - 1] = -1;
if (sum == 0) break;
sum -= n - i;
a.push_back(n - i);
arr[n - i - 1] = -1;
}
cout << a.size() << endl;
for (auto i : a) cout << i << " ";
cout << endl;
cout << n - a.size() << endl;
for (long long i = 0; i < n; i++) {
if (arr[i] != -1) cout << arr[i] << " ";
}
cout << endl;
} else {
sum -= n;
long long cnter = 1;
a.push_back(n);
arr[n - 1] = -1;
for (long long i = 1; sum != 0; i++) {
sum -= i;
a.push_back(i);
arr[i - 1] = -1;
if (sum == 0) break;
sum -= n - i;
a.push_back(n - i);
arr[n - i - 1] = -1;
}
cout << a.size() << endl;
for (auto i : a) cout << i << " ";
cout << endl;
cout << n - a.size() << endl;
for (long long i = 0; i < n; i++) {
if (arr[i] != -1) cout << arr[i] << " ";
}
cout << endl;
}
}
set<string> str;
void permute(string s, int l, int r) {
if (l == r) {
str.insert(s);
} else {
for (int i = l; i <= r; i++) {
swap(s[i], s[l]);
permute(s, l + 1, r);
swap(s[i], s[l]);
}
}
}
int main() {
int n, x, a, c, d, e, f;
cin >> n;
cin >> x;
a = 7 - x;
int flag = 0;
while (n--) {
int arr[6] = {1, 2, 3, 4, 5, 6};
cin >> c >> d;
e = 7 - c;
f = 7 - d;
arr[c - 1] = 0, arr[d - 1] = 0, arr[e - 1] = 0, arr[f - 1] = 0,
arr[a - 1] = 0;
if (c == a || d == a || e == a || f == a) {
flag = 1;
} else {
for (int i = 0; i < 6; i++) {
if (arr[i] != 0) {
a = arr[i];
break;
}
}
}
}
if (flag)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
long long f[87],n;
int main()
{
cin>>n;
f[0]=2;
f[1]=1;
for(int i=2;i<=n;i++){
f[i]=f[i-1]+f[i-2];
}
cout<<f[n];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, -1, 1, 1, 0, 1, 0, -1};
int dy[] = {-1, 1, -1, 1, 1, 0, -1, 0};
const int N = 2e5 + 10, M = 1e6 + 10, OOm = 0x3f3f3f3f;
string blank = "";
int xO, yO, xN, yN, n;
map<int, set<int>> segments;
map<pair<int, int>, bool> vis;
bool valid(int x, int y) {
if (segments.find(x) != segments.end())
if (segments[x].count(y)) return true;
return false;
}
int bfs() {
queue<pair<int, pair<int, int>>> q;
q.push({0, {xO, yO}});
while (!q.empty()) {
auto cell = q.front();
q.pop();
for (int i = 0; i < 8; i++) {
int nx = cell.second.first + dx[i];
int ny = cell.second.second + dy[i];
if (valid(nx, ny) && !vis[{nx, ny}]) {
vis[{nx, ny}] = true;
if (nx == xN && ny == yN) return cell.first + 1;
q.push({cell.first + 1, {nx, ny}});
}
}
}
return -1;
}
void solve() {
cin >> xO >> yO >> xN >> yN >> n;
for (int i = 0; i < n; i++) {
int r, a, b;
cin >> r >> a >> b;
for (int i = a; i <= b; i++) {
segments[r].insert(i);
}
}
cout << bfs();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
cerr << "Time elapsed: " << clock() / 1000 << " ms" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const int MAXN = 200005;
long long qpow(long long d, long long z) {
long long res = 1;
for (; z; z >>= 1) {
if (z & 1) res = res * d % MOD;
d = d * d % MOD;
}
return res;
}
int n;
int d[MAXN];
int t[MAXN];
bool check(int x) {
for (int i = 1; i <= n; i++) t[i] = d[i];
for (int i = n; i >= 3; i--) {
if (t[i] < x) return 0;
int z = t[i] - x;
if (z > d[i]) z = d[i];
z /= 3;
t[i - 1] += z;
t[i - 2] += z + z;
}
if (t[1] < x || t[2] < x) return 0;
return 1;
}
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &d[i]);
}
int l = 1, r = d[n], ans = 1;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid)) {
l = mid + 1;
ans = mid;
} else
r = mid - 1;
}
printf("%d\n", ans);
return;
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int n, m;
scanf("%d%d", &n, &m);
vector<vector<int> > a(n + 1, vector<int>(m + 1)),
numr(n + 1, vector<int>(m + 1)), numc(n + 1, vector<int>(m + 1));
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) {
a[i][j] = numr[i][j] = numc[i][j] = 0;
}
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
for (int j = 1; j <= s.size(); j++) {
numr[i][j] = numr[i][j - 1];
numc[i][j] = numc[i - 1][j];
if (s[j - 1] == '*') {
a[i][j] = 1;
numr[i][j]++;
numc[i][j]++;
}
}
}
int ans = 9999999;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int x = numr[i][m] + numc[n][j] - a[i][j];
ans = min(ans, n + m - 1 - x);
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
Point(int a = 0, int b = 0) : x(a), y(b) {}
Point operator-(const Point &p) const { return Point(x - p.x, y - p.y); }
bool operator<(const Point &p) const {
return x < p.x || (x == p.x && y < p.y);
}
};
long long Cross(const Point &u, const Point &v) {
return (long long)u.x * v.y - (long long)u.y * v.x;
}
long long Dot(const Point &u, const Point &v) {
return (long long)u.x * v.x + (long long)u.y * v.y;
}
multiset<Point> st1, st2;
multiset<Point>::iterator it1, it2;
int n;
Point tp[4];
void init() {
sort(tp, tp + 3);
st1.clear();
st2.clear();
st1.insert(tp[0]);
st1.insert(tp[2]);
st2.insert(tp[0]);
st2.insert(tp[2]);
if (Cross(tp[1] - tp[0], tp[2] - tp[0]) > 0) {
st1.insert(tp[1]);
} else
st2.insert(tp[1]);
}
bool IsPointOnSeg(const Point &u, const Point &v, const Point &p) {
if (Cross(u - p, v - p) == 0 && Dot(u - p, v - p) <= 0) return 1;
return 0;
}
int IsInDownConvexHull(const Point &u) {
if (st1.count(u) > 0) return 1;
it2 = it1 = st1.upper_bound(u);
if (it1 == st1.begin()) return 0;
if (it1 == st1.end()) return 0;
it2--;
long long k = Cross((*it2) - u, (*it1) - u);
if (k >= 0)
return 1;
else
return 0;
}
int IsInUpConvexHull(const Point &u) {
if (st2.count(u) > 0) return 1;
it2 = it1 = st2.upper_bound(u);
if (it1 == st2.end()) return 0;
if (it1 == st2.begin()) return 0;
it2--;
long long k = Cross((*it2) - u, (*it1) - u);
if (k <= 0)
return 1;
else
return 0;
}
multiset<Point>::iterator findPre(multiset<Point> &st, const Point &u) {
multiset<Point>::iterator it;
it = st.lower_bound(u);
if (it == st.begin()) return st.end();
it--;
return it;
}
multiset<Point>::iterator findNext(multiset<Point> &st, const Point &u) {
multiset<Point>::iterator it;
it = st.upper_bound(u);
return it;
}
void Insert(const Point &u) {
int tmp2 = IsInUpConvexHull(u), tmp1 = IsInDownConvexHull(u);
if (tmp1 && tmp2) return;
if (tmp1 == 0) {
while (1) {
it1 = findNext(st1, u);
if (it1 == st1.end()) break;
it2 = findNext(st1, *it1);
if (it2 == st1.end()) break;
long long k = Cross((*it1) - u, (*it2) - u);
if (k <= 0) {
st1.erase(*it1);
} else
break;
}
while (1) {
it1 = findPre(st1, u);
if (it1 == st1.end()) break;
it2 = findPre(st1, *it1);
if (it2 == st1.end()) break;
long long k = Cross((*it1) - u, (*it2) - u);
if (k >= 0) {
st1.erase(*it1);
} else
break;
}
st1.insert(u);
}
if (tmp2 == 0) {
while (1) {
it1 = findNext(st2, u);
if (it1 == st2.end()) break;
it2 = findNext(st2, *it1);
if (it2 == st2.end()) break;
long long k = Cross((*it1) - u, (*it2) - u);
if (k >= 0) {
st2.erase(*it1);
} else
break;
}
while (1) {
it1 = findPre(st2, u);
if (it1 == st2.end()) break;
it2 = findPre(st2, *it1);
if (it2 == st2.end()) break;
long long k = Cross((*it1) - u, (*it2) - u);
if (k <= 0) {
st2.erase(*it1);
} else
break;
}
st2.insert(u);
}
}
void Insert1(const Point &u) {
int tmp1 = IsInUpConvexHull(u), tmp2 = IsInDownConvexHull(u);
if (tmp1 && tmp2) return;
it1 = it2 = st1.upper_bound(u);
if (it1 == st1.end()) {
it1--;
it1--;
it2--;
while (1) {
long long k = Cross((*it2) - u, (*it1) - u);
if (k >= 0) {
Point t = *it2;
it2--;
st1.erase(t);
if (it1 == st1.begin()) break;
it1--;
} else
break;
}
st1.insert(u);
it1 = it2 = st2.end();
it1--;
it1--;
it2--;
while (1) {
long long k = Cross((*it2) - u, (*it1) - u);
if (k <= 0) {
Point t = *it2;
it2--;
st2.erase(t);
if (it1 == st2.begin()) break;
it1--;
} else
break;
}
st2.insert(u);
return;
}
if (it1 == st1.begin()) {
it2++;
while (it2 != st1.end()) {
long long k = Cross((*it1) - u, (*it2) - u);
if (k <= 0) {
Point t = *it1;
it1++;
it2++;
st1.erase(t);
} else
break;
}
st1.insert(u);
it1 = it2 = st2.begin();
it2++;
while (it2 != st2.end()) {
long long k = Cross((*it1) - u, (*it2) - u);
if (k >= 0) {
Point t = *it1;
it1++;
it2++;
st2.erase(t);
} else
break;
}
st2.insert(u);
return;
}
if (tmp1 == 0) {
it2 = it1 = st2.upper_bound(u);
it2++;
while (it2 != st2.end()) {
long long k = Cross((*it1) - u, (*it2) - u);
if (k >= 0) {
Point t = *it1;
it1++;
it2++;
st2.erase(t);
} else
break;
}
st2.insert(u);
it2 = it1 = st2.lower_bound(u);
it1--;
if (it1 != st2.begin()) {
it1--;
it2--;
while (1) {
long long k = Cross((*it2) - u, (*it1) - u);
if (k <= 0) {
Point t = *it2;
it2--;
st2.erase(t);
if (it1 == st2.begin()) break;
it1--;
} else
break;
}
}
} else if (tmp2 == 0) {
it2 = it1 = st1.upper_bound(u);
it2++;
while (it2 != st1.end()) {
long long k = Cross((*it1) - u, (*it2) - u);
if (k <= 0) {
Point t = *it1;
it1++;
it2++;
st1.erase(t);
} else
break;
}
st1.insert(u);
it2 = it1 = st1.lower_bound(u);
it1--;
if (it1 != st1.begin()) {
it1--;
it2--;
while (1) {
long long k = Cross((*it2) - (*it1), u - (*it1));
if (k <= 0) {
Point t = *it2;
it2--;
st1.erase(t);
if (it1 == st1.begin()) break;
it1--;
} else
break;
}
}
}
}
void solve() {
init();
for (int i = 3; i < n; i++) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
Insert(Point(x, y));
} else {
int t1 = IsInUpConvexHull(Point(x, y));
int t2 = IsInDownConvexHull(Point(x, y));
if ((t1 && t2))
printf("YES\n");
else
printf("NO\n");
}
}
}
int main() {
while (~scanf("%d", &n)) {
st1.clear();
st2.clear();
for (int i = 0; i < 3; i++) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
tp[i] = Point(x, y);
}
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long qpow(long long a, long long b) {
long long s = 1;
while (b > 0) {
if (b % 2 == 1) {
s = s * a;
}
a = a * a;
b = b >> 1;
}
return s;
}
long long qpowmod(long long a, long long b, long long c) {
long long res, t;
res = 1;
t = a % c;
while (b) {
if (b & 1) {
res = res * t % c;
}
t = t * t % c;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long read() {
long long k = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k * f;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
long long t, a, b, c, ans;
int main() {
cin >> t;
while (t--) {
cin >> a >> b >> c;
ans = 0;
if (a >= 1) {
a--;
ans++;
}
if (b >= 1) {
b--;
ans++;
}
if (c >= 1) {
c--;
ans++;
}
if (a >= b && a >= c) {
if (a >= 1 && b >= 1) {
a--;
b--;
ans++;
}
if (a >= 1 && c >= 1) {
a--;
c--;
ans++;
}
if (b >= 1 && c >= 1) {
b--;
c--;
ans++;
}
} else if (b >= a && b >= c) {
if (b >= 1 && a >= 1) {
a--;
b--;
ans++;
}
if (b >= 1 && c >= 1) {
b--;
c--;
ans++;
}
if (a >= 1 && c >= 1) {
a--;
c--;
ans++;
}
} else if (c >= b && c >= a) {
if (c >= 1 && b >= 1) {
c--;
b--;
ans++;
}
if (c >= 1 && a >= 1) {
a--;
c--;
ans++;
}
if (a >= 1 && b >= 1) {
a--;
b--;
ans++;
}
}
if (a >= 1 && b >= 1 && c >= 1) {
ans++;
}
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <iostream>
#include <vector>
using namespace std;
int main()
{
string s;
while(getline(cin, s)) {
if(s == "END OF INPUT") break;
int count = 0;
vector<int> num;
for (int i = 0; i < s.size(); i++) {
if(s[i]==' ') {
num.push_back(count);
count = 0;
}
else count++;
}
num.push_back(count);
for (int i = 0; i < num.size(); i++) {
cout << num[i];
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
do {
ios::sync_with_stdio(0);
cin.tie(0);
} while (0);
int n;
cin >> n;
long long res = 0;
for (int i = 2; i <= n / 2; i++) {
for (int j = 2; i * j <= n; j++) {
res += j * 4;
}
}
cout << res << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[30];
bool ch(long long m, long long w) {
long long v = m * w;
for (int i = 0; i < 30; i++) v -= m * (a[i] / m);
return (v <= 0);
}
int main() {
ios::sync_with_stdio(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
memset(a, 0, sizeof a);
for (int i = 0; i < n; i++) a[(s[i] - 'a')]++;
long long ans = 0;
for (int i = 1; i < k + 1; i++) {
if (k % i == 0) {
long long R = 2020, L = 1;
long long Mid;
while (L != R) {
Mid = (L + R) / 2;
bool e = ch(Mid, i);
if (e && !ch(Mid + 1, i)) {
ans = max(ans, (i * Mid));
break;
} else if (!e)
R = Mid;
else if (e)
L = Mid + 1;
}
}
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long smallestPrime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
return i;
}
}
return n;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long count = 0;
while (n > 0) {
if (n % 2 == 0) {
count += n / 2;
n = 0;
} else {
long long t = smallestPrime(n);
n -= t;
count++;
}
}
cout << count << "\n";
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,cnt=0;
cin >> N;
int a[N];
for(int i=0;i<N;i++) cin >> a[i];
for(int i=0;i<N;i++){
int c=1;
for(int j=2;j<=sqrt(a[i]);j++){
if(a[i]%j==0) c=0;
}
if(c==1) cnt++;
}
cout << cnt << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, dp[105][22][22], old[105][22][22], ans;
vector<int> v[105];
inline void add(int &x, long long y) { x = (y + x) % 1000000007; }
void dfs(int x, int y) {
dp[x][1][0] = 1;
dp[x][0][m + 1] = 1;
for (int i = (0); i < (v[x].size()); i++) {
int z = v[x][i];
if (z == y) continue;
dfs(z, x);
for (int j = (0); j <= (m); j++)
for (int k = (0); k <= (m + 1); k++) {
old[x][j][k] = dp[x][j][k];
dp[x][j][k] = 0;
}
for (int j = (0); j <= (m); j++)
for (int k = (0); k <= (m + 1); k++)
if (!j || j > k)
for (int jj = (0); jj <= (m); jj++)
for (int kk = (0); kk <= (m + 1); kk++)
if (!jj || jj > kk) {
int nj = max(j, jj + 1);
int nk = max(k, kk - 1);
if (nj <= nk) nj = 0;
if (nj > m) continue;
add(dp[x][nj][nk], (long long)old[x][j][k] * dp[z][jj][kk]);
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (1); i < (n); i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 0);
for (int i = (0); i <= (m + 1); i++) add(ans, dp[1][0][i]);
printf("%d\n", ans);
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int a,a1,b,b1;
int main()
{
cin>>a>>a1>>b>>b1;
if(a+a1>b+b1)cout<<"Left";
if(a+a1<b+b1)cout<<"Right";
if(a+a1==b+b1)cout<<"Balanced";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[55];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (k > n)
cout << -1 << endl;
else if (k == 0)
cout << a[n - 1] + 1 << " " << 0 << endl;
else
cout << a[n - k] << " " << 0 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,x,y) for(int i=(x);i<(y);++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define show(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define show(x)
#endif
typedef long long int ll;
typedef pair<int,int> pii;
template<typename T> using vec=std::vector<T>;
const int inf=1<<30;
const long long int infll=1LL<<62;
const double eps=1e-9;
const int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
template<class segment_type,class connection_type> struct HLDecomposition{
const vector<vector<int>> graph;
const int root,n;
vector<int> parent,subtree_size,depth,
first,last,prev,next,path_id,at;
vector<vector<int>> paths,children;
vector<segment_type> segments;
vector<connection_type> connections;
HLDecomposition(const vector<vector<int>> &graph,int root):graph(graph),root(root),n(graph.size()),
parent(n),subtree_size(n,1),depth(n),first(n),last(n),prev(n,-1),next(n,-1),path_id(n),at(n)
{
preprocess();
decompose();
segments.resize(paths.size());
connections.resize(paths.size());
}
void preprocess(){
stack<tuple<int,int,int>> dfs_stack;
dfs_stack.push(make_tuple(root,-1,0));
while(!dfs_stack.empty()){
auto t=dfs_stack.top();
dfs_stack.pop();
int v=get<0>(t),p=get<1>(t),i=get<2>(t);
if(i==0){
if(v!=root) depth[v]=depth[p]+1;
dfs_stack.push(make_tuple(v,p,1));
for(int u:graph[v]){
if(u==p) continue;
dfs_stack.push(make_tuple(u,v,0));
}
}else{
parent[v]=p;
for(int u:graph[v]){
if(u==p) continue;
subtree_size[v]+=subtree_size[u];
}
}
}
}
void decompose(){
int cnt=0;
stack<pii> dfs_stack;
dfs_stack.push(make_pair(root,0));
while(!dfs_stack.empty()){
auto p=dfs_stack.top();
dfs_stack.pop();
int v=p.first,id=p.second;
if(paths.size()<=cnt) paths.resize(cnt+1);
if(children.size()<=cnt) children.resize(cnt+1);
int cur=v;
while(cur!=-1){
paths[id].push_back(cur);
int heavy_edge=-1;
for(int u:graph[cur]){
if(u==parent[cur]) continue;
if(heavy_edge==-1 and subtree_size[u]*2>=subtree_size[cur]-1) heavy_edge=u;
else{
++cnt;
children[id].push_back(cnt);
dfs_stack.push(make_pair(u,cnt));
}
}
cur=heavy_edge;
}
for(int i=0; i<paths[id].size(); ++i){
int u=paths[id][i];
first[u]=paths[id].front();
last[u]=paths[id].back();
if(i!=0) prev[u]=paths[id][i-1];
if(i!=paths[id].size()-1) next[u]=paths[id][i+1];
path_id[u]=id;
at[u]=i;
}
}
}
int size()const{
return n;
}
int go_up(int v){
return parent[first[v]];
}
std::pair<int,int> get_index(int v){
return make_pair(path_id[v],at[v]);
}
int lca(int u,int v){
while(path_id[u]!=path_id[v]){
if(depth[first[u]]<depth[first[v]]) v=go_up(v);
else u=go_up(u);
}
return depth[u]<depth[v]?u:v;
}
int highest_child(int path_id,int idx){ //local index???idx??\????????????????????\?¶?????????????????????????????????§???????????????????????????children[path_id]???index
int lb=-1,ub=children[path_id].size();
while(ub-lb>1){
int m=(lb+ub)/2;
if(at[go_up(paths[children[path_id][m]].front())]>=idx) ub=m;
else lb=m;
}
return ub;
};
};
//range add,get sum
template<class T> class segtree{
public:
int n,size_;
vector<T> dat,sum; //????????????,?????????????§?????¶?????????????
segtree(){}
segtree(int size_,T x):size_(size_){
n=1;
while(n<size_) n*=2;
dat.assign(2*n-1,x);
sum.assign(2*n-1,x);
}
int size()const{ return size_; }
void add(int a,int b,T x){ add(a,b,x,0,0,n); }
T add(int a,int b,T x,int k,int l,int r){
if(b<=l or r<=a) return dat[k];
if(a<=l and r<=b){
sum[k]+=x;
return dat[k]+=x*(r-l);
}
int m=(l+r)/2;
return dat[k]=add(a,b,x,2*k+1,l,m)+add(a,b,x,2*k+2,m,r)+sum[k]*(r-l);
}
T query(int a,int b){ return query(a,b,0,0,n); }
T query(int a,int b,int k,int l,int r){
if(b<=l or r<=a) return 0;
if(a<=l and r<=b) return dat[k];
int m=(l+r)/2;
return query(a,b,2*k+1,l,m)+query(a,b,2*k+2,m,r)+sum[k]*(min(r,b)-max(l,a));
}
};
void solve(){
int n,q;
cin >> n >> q;
vector<vector<int>> graph(n);
rep(i,0,n-1){
int a,b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
HLDecomposition<segtree<ll>,segtree<ll>> hld(graph,0);
rep(i,0,hld.paths.size()){
hld.segments[i]=segtree<ll>(hld.paths[i].size()-1,0);
hld.connections[i]=segtree<ll>(hld.children[i].size(),0);
}
rep(i,0,q){
int t;
cin >> t;
if(!t){
int u,v,w;
cin >> u >> v;
w=hld.lca(u,v);
function<ll(int,int)> rec=[&](int x,int d){
ll res=hld.segments[hld.path_id[x]].query(0,hld.at[x]);
int y=hld.go_up(x);
if(y==-1) return res;
d+=hld.at[x]+1;
int i=hld.highest_child(hld.path_id[y],hld.at[y]);
return res+hld.connections[hld.path_id[y]].query(i,i+1)*d+rec(y,d);
};
cout << rec(u,0)+rec(v,0)-rec(w,0)*2 << endl;
}else{
int v;
ll val;
cin >> v >> val;
int c=hld.path_id[v];
hld.segments[c].add(hld.at[v],hld.segments[c].size(),val);
hld.connections[c].add(hld.highest_child(c,hld.at[v]),hld.connections[c].size(),val);
}
}
}
int main(){
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 300000;
const int def = 0x3f3f3f3f;
struct part {
int l, r;
bool operator<(const part &a) const { return r > a.r; }
} a[Max];
int b[Max];
long long vision[Max];
int cmp(part x, part y) { return x.l < y.l; }
int main() {
int i, j, h;
int n, m;
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d", &b[i]);
if (i >= 2) {
int xx = min(b[i], b[i - 1]);
int yy = max(b[i], b[i - 1]);
a[i - 1].l = xx;
a[i - 1].r = yy;
if (xx == yy) continue;
vision[xx] += (yy - 1) - (yy - xx);
vision[yy] += (xx) - (yy - xx);
}
}
sort(a + 1, a + m, cmp);
long long shuchu = 0;
int base = 1;
priority_queue<part> q;
for (i = 1; i <= n; i++) {
while (q.size() && q.top().r <= i) q.pop();
if (i == 1) {
for (j = 2; j <= m; j++) shuchu += abs(b[j] - b[j - 1]);
printf("%lld ", shuchu);
} else {
printf("%lld ", shuchu - q.size() + vision[i]);
}
while (base <= m - 1 && a[base].l == i) q.push(a[base++]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, i, pn, mn, sn, ans;
vector<int> pro;
vector<int> mat;
vector<int> spo;
while (scanf("%d", &n) == 1) {
pn = sn = mn = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a);
if (a == 1) {
pro.push_back(i);
pn++;
} else if (a == 2) {
mat.push_back(i);
mn++;
} else {
spo.push_back(i);
sn++;
}
}
if (pn == 0 || sn == 0 || mn == 0) {
printf("0\n");
pro.clear();
mat.clear();
spo.clear();
continue;
}
ans = min(pn, min(sn, mn));
printf("%d\n", ans);
for (i = 0; i < ans; i++) {
printf("%d %d %d\n", pro[i], mat[i], spo[i]);
}
pro.clear();
mat.clear();
spo.clear();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void prn(Arg1&& arg1) {
cout << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void prn(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prn(args...);
}
template <typename Arg1>
void prs(Arg1&& arg1) {
cout << arg1 << " ";
}
template <typename Arg1, typename... Args>
void prs(Arg1&& arg1, Args&&... args) {
cout << arg1 << " ";
prs(args...);
}
template <typename Arg1>
void read(Arg1&& arg1) {
cin >> arg1;
}
template <typename Arg1, typename... Args>
void read(Arg1&& arg1, Args&&... args) {
cin >> arg1;
read(args...);
}
inline void solve();
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for (int tc = 1; tc <= t; ++tc) {
solve();
}
return 0;
}
const int N = 5e3 + 1, inf = 1e9;
vector<int> adj[N];
vector<pair<int, int> > avail[N];
int n, m;
void qry() {
int s, need, cost;
read(s, need, cost);
priority_queue<pair<long long, long long> > q;
long long price = 0;
auto relax = [&](int idx) {
for (auto have : avail[idx]) {
long long tak = min(have.second, need);
need -= tak;
while (tak < have.second && !q.empty() && q.top().first > have.first) {
pair<long long, long long> cur = q.top();
q.pop();
int ctake = min(have.second - tak, cur.second);
tak += ctake;
cur.second -= ctake;
price -= cur.first * ctake;
if (!cur.second) continue;
q.push(cur);
}
price += have.first * tak;
if (tak) q.push({have.first, tak});
}
};
vector<int> dist(n + 1, -1);
dist[s] = 0;
queue<int> bq;
bq.push(s);
int ans = inf;
while (!bq.empty()) {
int cur = bq.front();
bq.pop();
relax(cur);
if (!need && price <= cost) {
prn(dist[cur]);
return;
}
for (auto i : adj[cur]) {
if (dist[i] != -1) continue;
dist[i] = dist[cur] + 1;
bq.push(i);
}
}
prn(-1);
}
inline void solve() {
read(n, m);
for (int i = 0; i < m; ++i) {
int a, b;
read(a, b);
adj[a].push_back(b);
adj[b].push_back(a);
}
int marts;
read(marts);
for (int i = 0; i < marts; ++i) {
int c, k, p;
read(c, k, p);
avail[c].emplace_back(p, k);
}
int q;
read(q);
while (q--) {
qry();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dp[1010][1010] = {};
int main(void) {
int sz, tz;
string s, t;
cin >> s >> t;
sz = s.size();
tz = t.size();
for (int i = 0; i <= tz; i++)
dp[0][i] = i;
for (int i = 0; i <= sz; i++)
dp[i][0] = i;
for (int i = 1; i <= sz; i++) {
for (int j = 1; j <= tz; j++) {
if (s[i - 1] == t[j - 1]) dp[i][j] = dp[i - 1][j - 1];
else dp[i][j] = min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1])) + 1;
}
}
cout << dp[sz][tz] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
bool flag = true;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (i % 2 != 0)
cout << "#";
else {
if (flag && j == m)
cout << "#";
else if (!flag && j == 1)
cout << "#";
else
cout << ".";
}
if (i % 2 == 0) flag = !flag;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long MOD_EXPO(long long b, long long p, long long m) {
if (p == 0) return 1;
long long ret = MOD_EXPO(b, p / 2, m) % m;
ret = (ret * ret) % m;
return ((p & 1) ? (ret * b) % m : ret % m);
}
long long POWER(long long N, long long K) {
long long i, ans = 1;
for (i = 1; i <= K; i++) ans *= N;
return ans;
}
int SET(int N, int pos) { return (N | (1 << pos)); }
int RESET(int N, int pos) { return (N & !(1 << pos)); }
bool CHECK(int N, int pos) { return (N & (1 << pos)); }
int dx4[] = {1, -1, 0, 0};
int dy4[] = {0, 0, 1, -1};
int dx6[] = {0, 0, 1, -1, 0, 0};
int dy6[] = {1, -1, 0, 0, 0, 0};
int dz6[] = {0, 0, 0, 0, 1, -1};
int dx8[] = {1, -1, 0, 0, -1, 1, -1, 1};
int dy8[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dkx8[] = {-1, 1, -1, 1, -2, -2, 2, 2};
int dky8[] = {2, 2, -2, -2, 1, -1, 1, -1};
int tc = 1;
const double eps = 1e-9;
const double pi = acos(-1.0);
const long long int mx = 1e5;
const long long int mod = 1e9 + 7;
int main() {
int i, adjective, noun, verb;
string str, ss;
vector<int> idx;
bool male, female, invalid;
vector<string> suffix;
suffix.push_back("lios");
suffix.push_back("liala");
suffix.push_back("etr");
suffix.push_back("etra");
suffix.push_back("initis");
suffix.push_back("inites");
ios::sync_with_stdio(0);
male = female = invalid = false;
while (cin >> str) {
for (i = 0; i < 6; i++) {
if (str.size() >= suffix[i].size()) {
ss = str.substr(str.size() - suffix[i].size(), suffix[i].size());
if (ss == suffix[i]) break;
}
}
invalid |= (i == 6);
male |= (i % 2 == 0);
female |= (i % 2 != 0);
idx.push_back(i / 2 + 1);
}
invalid |= (male == female);
adjective = noun = verb = 0;
i = 0;
while (i < idx.size() && idx[i] == 1) i++, adjective++;
while (i < idx.size() && idx[i] == 2) i++, noun++;
while (i < idx.size() && idx[i] == 3) i++, verb++;
printf("%s\n", (!invalid && ((adjective >= 0 && noun == 1 && verb >= 0 &&
i == idx.size() && idx.size() > 1) ||
(idx.size() == 1)))
? "YES"
: "NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
map<char, int> A;
A['Q'] = 9;
A['R'] = 5;
A['B'] = 3;
A['N'] = 3, A['P'] = 1;
A['K'] = 0;
A['q'] = 9;
A['r'] = 5;
A['b'] = 3;
A['n'] = 3, A['p'] = 1;
A['k'] = 0;
char B[8][8], temp;
int white = 0, black = 0, i, j;
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) cin >> B[i][j];
}
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
if (B[i][j] >= 'A' && B[i][j] <= 'Z')
white += A[B[i][j]];
else if (B[i][j] >= 'a' && B[i][j] <= 'z')
black += A[B[i][j]];
else
continue;
}
}
if (white == black)
cout << "Draw" << endl;
else if (white > black)
cout << "White" << endl;
else
cout << "Black" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 + 10;
const int MOD = 1e9 + 7;
int n;
double a[N];
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
double ret = 0;
for (int i = 0; i < n; ++i) {
double cur = a[i];
double v = 1 - a[i];
for (int j = i - 1; j >= 0; --j) {
if (cur * (1 - a[j]) + v * a[j] > cur) {
cur = cur * (1 - a[j]) + v * a[j];
v *= 1 - a[j];
}
}
ret = max(ret, cur);
}
printf("%.10f\n", ret);
}
int main() {
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long MAXN = 2e5 + 10;
const long long MAXM = MAXN << 1;
bool vis[MAXN], if_in[MAXN];
long long n, m, Q, cntPath, cntEdge = 1;
long long disZ[MAXN], disF[MAXN], Min[MAXM << 1];
long long head[MAXN], nxt[MAXM], to[MAXM], val[MAXM];
long long from[MAXN], per[MAXN], Id[MAXN], dep[MAXN], fa[20][MAXN];
inline long long read() {
long long X = 0, flag = 0;
char ch = 0;
while (!isdigit(ch)) flag |= ch == '-', ch = getchar();
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return flag ? -X : X;
}
inline void add_edge(long long u, long long e, long long v) {
to[++cntEdge] = e, val[cntEdge] = v;
nxt[cntEdge] = head[u], head[u] = cntEdge;
}
struct Point {
Point(long long Identity, long long Distance) : id(Identity), d(Distance) {}
long long id;
long long d;
};
inline bool operator<(Point const &lhs, Point const &rhs) {
return lhs.d > rhs.d;
}
inline void Dijkstra(long long S, long long (&dis)[MAXN]) {
for (long long i = 1; i <= n; ++i) dis[i] = INF, vis[i] = false;
dis[S] = 0, from[S] = 0;
priority_queue<Point> q;
q.push(Point(S, 0));
while (!q.empty()) {
long long x = q.top().id;
q.pop();
if (vis[x]) continue;
vis[x] = true;
for (long long i = head[x]; i; i = nxt[i]) {
long long v = to[i];
if (dis[v] <= dis[x] + val[i]) continue;
dis[v] = dis[x] + val[i];
from[v] = i;
q.push(Point(v, dis[v]));
}
}
}
inline void getTree() {
for (long long i = 1; i <= n; ++i) per[i] = i;
sort(per + 1, per + n + 1,
[](long long a, long long b) -> bool { return disZ[a] < disZ[b]; });
for (long long i = 1; i <= n; ++i) {
long long x = per[i];
fa[0][x] = to[from[x] ^ 1];
if (x == 1) fa[0][x] = 1;
dep[x] = dep[fa[0][x]] + 1;
for (long long j = 1; j <= 18; ++j) fa[j][x] = fa[j - 1][fa[j - 1][x]];
}
}
inline void findPath() {
per[0] = 0;
for (long long x = n; x != 1; x = to[from[x] ^ 1]) {
if_in[from[x] >> 1] = true;
per[++per[0]] = to[from[x] ^ 1];
}
for (long long i = per[0]; i >= 1; --i) Id[per[i]] = ++cntPath;
Id[n] = cntPath + 1;
}
inline long long lca(long long x, long long y) {
if (dep[x] < dep[y]) std::swap(x, y);
for (long long j = 18; ~j; --j)
if (dep[fa[j][x]] >= dep[y]) x = fa[j][x];
if (x == y) return x;
for (long long j = 18; ~j; --j)
if (fa[j][x] != fa[j][y]) x = fa[j][x], y = fa[j][y];
return fa[0][x];
}
inline long long disExcept(long long i) {
return std::min(disZ[to[i << 1]] + disF[to[i << 1 | 1]],
disZ[to[i << 1 | 1]] + disF[to[i << 1]]);
}
inline long long disCross(long long i) { return disExcept(i) + val[i << 1]; }
inline void Modify(long long p, long long L, long long R, long long l,
long long r, long long v) {
if (l <= L && R <= r) {
Min[p] = std::min(Min[p], v);
return;
}
if (Min[p] <= v) return;
long long mid = (L + R) >> 1;
if (l <= mid) Modify(p << 1, L, mid, l, r, v);
if (r > mid) Modify(p << 1 | 1, mid + 1, R, l, r, v);
}
inline long long query(long long p, long long L, long long R, long long x) {
if (L == R) return Min[p];
long long mid = (L + R) >> 1;
if (x <= mid)
return std::min(Min[p], query(p << 1, L, mid, x));
else
return std::min(Min[p], query(p << 1 | 1, mid + 1, R, x));
}
signed main() {
n = read(), m = read(), Q = read();
long long x, y, z;
for (long long i = 1; i <= m; ++i) {
x = read(), y = read(), z = read();
add_edge(x, y, z), add_edge(y, x, z);
}
Dijkstra(1, disZ), getTree(), findPath(), Dijkstra(n, disF);
memset(Min, 0x3f, sizeof(Min));
for (long long i = 1; i <= m; ++i) {
if (if_in[i]) continue;
long long u = to[i << 1], e = to[i << 1 | 1];
long long dis = disCross(i);
u = lca(u, n), e = lca(e, n);
if (u == e) continue;
if (Id[u] > Id[e]) std::swap(u, e);
Modify(1, 1, cntPath, Id[u], Id[e] - 1, dis);
}
for (long long i = 1; i <= Q; ++i) {
x = read(), z = read();
if (if_in[x]) {
if (z <= val[x << 1])
printf("%lld\n", disExcept(x) + z);
else {
long long ans = disExcept(x) + z;
long long u = to[x << 1], e = to[x << 1 | 1];
if (Id[u] > Id[e]) std::swap(u, e);
ans = std::min(ans, query(1, 1, cntPath, Id[u]));
printf("%lld\n", ans);
}
} else {
long long ans = disZ[n];
if (z <= val[x << 1]) ans = std::min(disZ[n], disExcept(x) + z);
printf("%lld\n", ans);
}
}
return 0;
}
| 6 |
#include<iostream>
#include<vector>
#include<map>
#include<set>
#include<string>
#include<utility>
#include<algorithm>
#include<cstdio>
#include<iomanip>
#include<queue>
#include<stack>
#define ll int64_t
#define Rep(i, n) for (ll i = 0; i < n; i++)
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> a(N, 0);
ll far = 0;
Rep (i, N) {
cin >> a[i];
if (abs(a[i]) > abs(a[far])) {
far = i;
}
}
ll m = 2 * N - 1;
cout << m << "\n";
Rep (i, N) {
cout << far+1 << " " << i+1 << "\n";
}
if (a[far] > 0) {
Rep (i, N-1) {
cout << i+1 << " " << i+2 << "\n";
}
} else {
Rep (i, N-1) {
cout << N-i << " " << N-i-1 << "\n";
}
}
cout << flush;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
int a[MAX];
double p[MAX][110];
int main() {
int n, q;
double ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
p[i][a[i]] = 1;
if (a[i] == 0) ans += 1;
}
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
int u, v, k;
scanf("%d%d%d", &u, &v, &k);
for (int j = 0; j < k; ++j) {
ans -= p[u][0];
for (int z = 0; z <= min(100, a[u]); ++z)
p[u][z] = (p[u][z] * (a[u] - z) + p[u][z + 1] * (z + 1)) / a[u];
ans += p[u][0];
a[u]--;
}
a[v] += k;
printf("%.10lf\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
while (a[i] % 2 == 0) a[i] /= 2;
while (a[i] % 3 == 0) a[i] /= 3;
}
for (int i = 0; i < n; i++) {
if (a[i] != a[0]) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 605;
const int MD = 1000000007;
int mod_mult(int a, int b) {
return (a * 1LL * b) % MD;
}
int dp[MX][MX];
int g[MX];
pair<int, int> p[MX];
bool in(int L, int R, int x) {
return L <= x && x <= R;
}
int cnt[MX][MX];
bool taken[MX];
int main()
{
g[0] = 1;
for (int i = 2; i < MX; i += 2) {
g[i] = mod_mult(g[i - 2], i - 1);
}
int n, k;
ignore = scanf("%d %d", &n, &k);
for (int i = 0; i < k; i++) {
ignore = scanf("%d %d", &p[i].first, &p[i].second);
taken[p[i].first] = true;
taken[p[i].second] = true;
}
for (int i = 1; i <= 2 * n; i++) {
for (int j = i; j <= 2 * n; j++) {
cnt[i][j] = cnt[i][j - 1] + (1 - taken[j]);
}
}
int ans = 0;
for (int l = 1; l <= 2 * n; l++) {
for (int i = 1; i + l <= 2 * n; i++) {
int j = i + l;
//printf("(%d %d):\n", i, j);
bool ok = true;
for (int t = 0; t < k; t++) {
if (in(i, j, p[t].first) != in(i, j, p[t].second)) {
ok = false;
break;
}
}
if (!ok) continue;
int x, y;
x = l + 1;
y = 2 * n - x;
for (int t = 0; t < k; t++) {
if (in(i, j, p[t].first)) {
x--;
}
else {
y--;
}
if (in(i, j, p[t].second)) {
x--;
}
else {
y--;
}
}
//printf("x = %d, y = %d\n", x, y);
int sub = 0;
//printf("before sub: %d\n", g[x]);
for (int t = i + 1; t < j; t++) {
sub = (sub + mod_mult(dp[i][t], g[cnt[t + 1][j]])) % MD;
}
dp[i][j] = (g[x] - sub + MD) % MD;
//printf("dp[%d][%d] = %d\n", i, j, dp[i][j]);
ans = (ans + mod_mult(dp[i][j], g[y])) % MD;
}
}
printf("%d", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct fastIO {
inline fastIO operator>>(int& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(long long& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(float& num) {
scanf("%f", &num);
return *this;
}
inline fastIO operator>>(double& num) {
scanf("%lf", &num);
return *this;
}
inline fastIO operator>>(long double& num) {
scanf("%Lf", &num);
return *this;
}
inline fastIO operator>>(char& num) {
num = getchar();
while (num == ' ' || num == '\n') num = getchar();
return *this;
}
inline fastIO operator>>(char* num) {
int cnt = 0;
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
while (c != ' ' && c != '\n') {
num[cnt++] = c;
c = getchar();
}
num[cnt] = 0;
return *this;
}
inline fastIO operator>>(string& num) {
cin >> num;
return *this;
}
inline void printInt(const int& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printInt(num / 10);
putchar((num % 10) + '0');
}
inline void printINT(const long long& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printINT(num / 10);
putchar((num % 10) + '0');
}
inline fastIO operator<<(const int& num) {
if (num < 0)
putchar('-'), printInt(-num);
else
printInt(num);
return *this;
}
inline fastIO operator<<(const long long& num) {
if (num < 0)
putchar('-'), printINT(-num);
else
printINT(num);
return *this;
}
inline fastIO operator<<(const float& num) {
printf("%.10f", num);
return *this;
}
inline fastIO operator<<(const double& num) {
printf("%.16lf", num);
return *this;
}
inline fastIO operator<<(const long double& num) {
printf("%.20Lf", num);
return *this;
}
inline fastIO operator<<(const char& num) {
putchar(num);
return *this;
}
inline fastIO operator<<(const char* num) {
for (int i = 0; num[i]; i++) putchar(num[i]);
return *this;
}
inline fastIO operator<<(const string& num) {
cout << num;
return *this;
}
} fio;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int n, m, k;
int fl[205];
int dp[(1 << (7)) + 5][205];
pair<int, int> go[(1 << (7)) + 5][205];
int X[10], Y[10];
char ans[205];
bool lgl[205];
inline int code(int x, int y) { return x * m + y; }
void dfs(int x, int y) {
ans[y] = 'X';
if (go[x][y].second == y) {
if (go[x][y].first) {
dfs(go[x][y].first, go[x][y].second);
dfs(x ^ go[x][y].first, go[x][y].second);
}
} else {
if (go[x][y].first) {
dfs(go[x][y].first, go[x][y].second);
}
}
}
int main() {
fio >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fio >> fl[code(i, j)];
}
}
memset((void*)dp, 0x3f, sizeof(dp));
for (int i = 0; i < k; i++) {
fio >> X[i] >> Y[i];
X[i]--;
Y[i]--;
dp[(1 << (i))][code(X[i], Y[i])] = fl[code(X[i], Y[i])];
}
for (int i = 1; i < (1 << (k)); i++) {
queue<int> q;
memset((void*)lgl, 0, sizeof(lgl));
for (int j = 0; j < n * m; j++) {
q.push(j);
lgl[j] = 1;
for (int k = i & (i - 1); k; k = i & (k - 1)) {
int val = dp[k][j] + dp[i ^ k][j] - fl[j];
if (val < dp[i][j]) {
dp[i][j] = val;
go[i][j] = make_pair(k, j);
}
}
}
while (((int)(q).size())) {
int j = q.front() / m, k = q.front() % m;
lgl[q.front()] = 0;
q.pop();
for (int l = 0; l < 4; l++) {
int x = j + dx[l], y = k + dy[l];
if (x < 0 || x >= n || y < 0 || y >= m) {
continue;
}
int num = dp[i][code(j, k)] + fl[code(x, y)];
if (num < dp[i][code(x, y)]) {
dp[i][code(x, y)] = num;
go[i][code(x, y)] = make_pair(i, code(j, k));
if (!lgl[code(x, y)]) {
q.push(code(x, y));
lgl[code(x, y)] = 1;
}
}
}
}
}
memset(ans, '.', sizeof(ans));
int minx = ((int)0x3f3f3f3f), mnpos;
for (int i = 0; i < n * m; i++) {
if (dp[(1 << (k)) - 1][i] < minx) {
minx = dp[(1 << (k)) - 1][i];
mnpos = i;
}
}
fio << minx << '\n';
dfs((1 << (k)) - 1, mnpos);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fio << ans[code(i, j)];
}
fio << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD(1e9 + 7);
int n, m, a[555], b[555], d[555][555];
int Compress(int l, int r) {
if (l > n) return r > m ? 555 : 0;
if (r > m) return l > n ? 555 : 0;
int& ret = d[l][r];
if (~ret) return ret;
ret = 0;
int s = 0, k;
for (k = l; k <= n; k++) {
s += a[k];
if (s >= b[r]) break;
}
if (s == b[r]) {
if (Compress(k + 1, r + 1)) return ret = k + 1;
}
return ret;
}
vector<pair<int, char>> output;
bool Reconstruct(int l, int r) {
if (l > n) return r > m;
if (r > m) return l > m;
int arg = l;
for (int k = l; k < d[l][r]; k++)
if (a[arg] <= a[k] && ((k + 1 < d[l][r] && a[k + 1] < a[k]) ||
(k - 1 >= l && a[k - 1] < a[k])))
arg = k;
int le = arg, ri = arg, cw = a[arg], base = r;
while (le > l || ri + 1 < d[l][r]) {
bool work = false;
if (le > l && cw > a[le - 1])
work = true, cw += a[le - 1], output.push_back({(le - l) + base, 'L'}),
--le;
if (ri + 1 < d[l][r] && cw > a[ri + 1])
work = true, cw += a[ri + 1], output.push_back({(le - l) + base, 'R'}),
++ri;
if (!work) {
return false;
}
}
return Reconstruct(d[l][r], r + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", b + i);
memset(d, -1, sizeof d);
if (Compress(1, 1) && Reconstruct(1, 1)) {
puts("YES");
for (auto& first : output) printf("%d %c\n", first.first, first.second);
} else {
puts("NO");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N, i, c=0, ans=0; cin >> N; string s[N], X; int t[N];
for(i=0; i<N; i++){ cin >> s[i] >> t[i]; }
cin >> X;
for(i=0; i<N; i++){ if(X==s[i]){ c=i; break; } }
for(i=c+1; i<N; i++){ ans+=t[i]; }
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long mod = 998244353;
template <typename T>
inline T gcd(T a, T b) {
return !b ? a : gcd(b, a % b);
}
template <typename T>
inline T q_pow(T a, T x) {
T ans = 1, tmp = a;
while (x) {
if (x & 1) (ans *= tmp) %= mod;
(tmp *= tmp) %= mod;
x >>= 1;
}
return ans;
}
template <typename T>
inline void re(T &N) {
int f = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') f = -1;
N = c - '0';
while ((c = getchar()) >= '0' && c <= '9') N = N * 10 + c - '0';
N *= f;
}
int m, n, t = 1, st, en;
long long mul[N], inv[N];
inline long long C(int m, int n) {
if (m > n || m < 0) return 0;
return mul[n] * inv[m] % mod * inv[n - m] % mod;
}
inline long long P(int m, int n) {
if (m > n || m < 0) return 0;
return mul[n] * inv[n - m] % mod;
}
long long a[N], l[N], r[N];
int main() {
mul[0] = 1;
for (int i = 1; i < N; i++) mul[i] = mul[i - 1] * i % mod;
inv[N - 1] = q_pow(mul[N - 1], mod - 2);
for (int i = N - 2; i >= 0; i--) (inv[i] = inv[i + 1] * (i + 1)) %= mod;
re(n);
re(m);
for (int i = 1; i <= n; i++) re(a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) l[i] = (a[i] + l[i - 1]) % mod;
for (int i = n; i >= 1; i--) r[i] = (a[i] + r[i + 1]) % mod;
for (int i = 1; i <= m; i++) {
long long x;
int y;
re(y);
re(x);
int pos = lower_bound(a + 1, a + n + 1, x) - a;
if (pos <= n) {
long long ans = 0;
(ans += r[pos] * C(y, n - pos) % mod * P(y, y) % mod *
P(n - pos - y + 1, n - pos - y + 1) % mod * C(pos - 1, n) % mod *
P(pos - 1, pos - 1) % mod) %= mod;
if (pos > 1)
(ans += l[pos - 1] * C(y, n - pos + 1) % mod * P(y, y) % mod *
P(n - pos - y + 1 + 1, n - pos - y + 1 + 1) % mod *
C(pos - 2, n) % mod * P(pos - 2, pos - 2) % mod) %= mod;
(ans *= inv[n]) %= mod;
printf("%lld\n", (ans + mod) % mod);
} else
puts("0");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tests;
cin >> tests;
for (int test = 1; test <= tests; test++) {
int n;
cin >> n;
vector<vector<int>> Arr(n, vector<int>(5));
vector<int> sum(5, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 5; j++) {
cin >> Arr[i][j];
sum[j] += Arr[i][j];
}
}
if (n % 2 == 1) {
cout << "NO\n";
continue;
}
vector<int> count;
for (int i = 0; i < 5; i++) {
if (sum[i] >= (n / 2)) count.push_back(i);
}
if (count.size() < 2) {
cout << "NO\n";
} else {
bool final_res = false;
for (int i = 0; i < count.size(); i++) {
for (int j = i + 1; j < count.size(); j++) {
int I = count[i], J = count[j];
bool res = true;
int count1 = 0, count2 = 0, both = 0;
for (int i = 0; i < n; i++) {
if (Arr[i][I] == 1 && Arr[i][J] == 1)
both++;
else if (Arr[i][I] == 1)
count1++;
else if (Arr[i][J] == 1)
count2++;
else {
res = false;
break;
}
}
if (res == false) continue;
if (count1 < (n / 2)) {
if (both < (n / 2) - count1) {
res = false;
break;
} else
both -= (n / 2) - count1;
}
if (res == false) continue;
if (count2 < (n / 2)) {
if (both < (n / 2) - count2) {
res = false;
break;
}
}
if (res == false) continue;
cout << "YES\n";
final_res = true;
if (final_res) break;
}
if (final_res) break;
}
if (final_res == false) {
cout << "NO\n";
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve(){
int n,k;
cin >> n >> k;
vector<int> v(n);
if(k>=(n+1)/2){
cout << -1 << endl;
return;
}
int a1=1;
int a2=n;
for(int i=0;i<n;i++){
if(k!=0 && i!=0 && i%2!=0){
v[i] = a2;
a2--;
k--;
}
else{
v[i] = a1;
a1++;
}
}
for(int i=0;i<n;i++){
cout << v[i] << " ";
}
cout << endl;
}
int main(){
int t;
cin >> t;
while(t--){
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (long long i = 0; i < (long long)n; i++) cin >> a[i];
int lst = 0;
vector<int> h(n);
h[0] = 0;
for (int i = 1; i < n; i++) {
if (i - 1 > 0 && a[i - 1] > a[i]) lst++;
h[i] = h[lst] + 1;
}
cout << h[n - 1] << endl;
}
return 0;
}
| 4 |
#include <iostream>
#include <cstdio>
using namespace std;
long long int DP[10][101][1001]; // DP[i][j][k] : ??????????????\??????????´???§????¨?????????¨????????????????????°
int main(){
int n, s, t;
long long int sum;
cin >> n >> s;
for(int i = 0; i < 10; i++){
for(int j = 0; j <= 100; j++){
for(int k = 0; k <= 1000; k++){
DP[i][j][k] = 0;
}
}
}
DP[1][0][0] = 1;
for(int i = 1; i <= 9; i++){
for(int j = 1; j <= 100; j++){
for(int k = 0; k <= 1000; k++){
if(i == 1 && j == k){
DP[i][j][k] = 1;
}else if(k - j < 0){
DP[i][j][k] = DP[i][j - 1][k];
}else{
DP[i][j][k] = DP[i][j - 1][k] + DP[i - 1][j - 1][k - j];
}
}
}
}
while(n != 0 || s != 0){
cout << DP[n][100][s] << endl;
cin >> n >> s;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
const int MAX_HW = 85;
int A[MAX_HW][MAX_HW],B[MAX_HW][MAX_HW];
bool dp[MAX_HW][MAX_HW][13000];
int main()
{
int H,W;
cin >> H >> W;
rep(i,H)
{
rep(j,W)
{
cin >> A[i][j];
}
}
rep(i,H)
{
rep(j,W)
{
cin >> B[i][j];
}
}
dp[0][0][abs(A[0][0]-B[0][0])] = true;
rep(i,H)
{
rep(j,W)
{
rep(k,13000)
{
if (dp[i][j][k])
{
dp[i+1][j][k+abs(A[i+1][j]-B[i+1][j])] = true;
dp[i+1][j][abs(k-abs(A[i+1][j]-B[i+1][j]))] = true;
dp[i][j+1][k+abs(A[i][j+1]-B[i][j+1])] = true;
dp[i][j+1][abs(k-abs(A[i][j+1]-B[i][j+1]))] = true;
}
}
}
}
rep(i,13000)
{
if (dp[H-1][W-1][i])
{
cout << i << endl;
return 0;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, A, B, C, T;
cin >> n >> A >> B >> C >> T;
long long t[n];
for (long long i = 0; i < n; i++) cin >> t[i];
long long S = 0;
S += A * n;
if (C > B) {
for (long long i = 0; i < n; i++) {
S += (C - B) * (T - t[i]);
}
}
cout << S;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long p[m];
for (int i = 0; i < m; ++i) {
cin >> p[i];
}
long long removed = 0, temp_rem = 0;
long long last_page = -1;
long long ops = 0;
for (int i = 0; i < m; ++i) {
long long page_num = ceil((long double)(p[i] - removed) / (long double)k);
if (last_page == -1) last_page = page_num;
if (page_num == last_page) {
++temp_rem;
} else {
removed += temp_rem;
temp_rem = 1;
++ops;
page_num = ceil((double)(p[i] - removed) / (double)k);
last_page = page_num;
}
}
cout << ops + 1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
int main() {
int n;
cin >> n;
pair<int, int> a[n];
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort(a, a + n, comp);
long long int sum1 = 0, sum2 = 0;
vector<int> t1, t2;
int ct = 1, ct1 = 1;
int g;
if (n % 2 == 0)
g = n / 2;
else
g = n / 2 + 1;
for (int j = n - 1; j >= 0; j--) {
if (abs(sum1 - sum2 + a[j].first) <= a[n - 1].first && ct <= g) {
if (ct == g && n % 2 == 1) g--;
sum1 += a[j].first;
t1.push_back(a[j].second);
ct++;
} else if (ct1 <= g) {
if (ct1 == g && n % 2 == 1) g--;
sum2 += a[j].first;
t2.push_back(a[j].second);
ct1++;
}
}
cout << t1.size() << endl;
for (auto i : t1) cout << i << " ";
cout << endl << t2.size() << endl;
for (auto i : t2) cout << i << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
pair<char, int> mas[100001];
cin >> n;
for (int i = 1; i <= 100000; i++) mas[i].second = 0;
for (int i = 1; i <= n; i++) cin >> mas[i].first;
for (int i = 1; i <= n; i++) cin >> mas[i].second;
int k = 1;
int jump = 0;
while (jump != 100001) {
if (mas[k].first == '>') k += mas[k].second;
if (k > n) {
cout << "FINITE";
return 0;
}
if (mas[k].first == '<') k -= mas[k].second;
if (k <= 0) {
cout << "FINITE";
return 0;
}
++jump;
}
cout << "INFINITE";
return 0;
}
| 2 |
#include <iostream>
using namespace std;
#define MAX 15
#define INF 10000
int main()
{
int v, e, s, t, p;
int d[MAX][MAX];
for (int i = 0; i < MAX; i++) {
for (int j = 0; j < MAX; j++) {
d[i][j] = INF;
}
}
for (int i = 0; i < MAX; i++) {
d[i][i] = 0;
}
cin >> v >> e;
for (int i = 0; i < e; i++) {
cin >> s >> t >> p;
d[s][t] = p;
}
int dp[1<<MAX][MAX];
for (s = 0; s < 1 << v; s++) {
fill(dp[s], dp[s] + v, INF);
}
dp[(1 << v) - 1][0] = 0;
for (int s = (1 << v) - 2; s >= 0; s--) {
for (int i = 0; i < v; i++) {
for (int j = 0; j < v; j++) {
if (!(s >> j & 1)) {
dp[s][i] = min(dp[s][i], dp[s | 1 << j][j] + d[i][j]);
}
}
}
}
if (dp[0][0] == INF) {
cout << -1 << endl;
}else{
cout << dp[0][0] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
for (int x = n; x >= 1; x /= 2) {
for (int i = 0; i < n; i += x) {
bool ok = 1;
for (int j = i; j < i + x - 1; ++j)
if (a[j] > a[j + 1]) ok = 0;
if (ok) {
cout << x << '\n';
return 0;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(int x) {
write(x);
puts("");
}
const int N = 1e5 + 5;
struct edge {
int link, next;
} e[N << 1];
int n, tot, head[N];
inline void add_edge(int u, int v) {
e[++tot] = (edge){v, head[u]};
head[u] = tot;
}
inline void insert(int u, int v) {
add_edge(u, v);
add_edge(v, u);
}
inline void init() {
n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
insert(u, v);
}
}
int dp[N], ans[N], cnt;
void dfs(int u, int fa, int x) {
dp[u] = 0;
int mx1, mx2;
mx1 = mx2 = 0;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].link;
if (v != fa) {
dfs(v, u, x);
if (dp[v] > mx1)
mx2 = mx1, mx1 = dp[v];
else
mx2 = max(mx2, dp[v]);
}
}
if (mx1 + mx2 + 1 >= x)
dp[u] = 0, cnt++;
else
dp[u] = mx1 + 1;
}
void sol(int l, int r, int L, int R) {
if (l > r || L > R) return;
if (L == R) {
for (int i = l; i <= r; i++) ans[i] = L;
return;
}
int mid = (l + r) >> 1;
cnt = 0;
dfs(1, 0, mid);
ans[mid] = cnt;
sol(l, mid - 1, cnt, R);
sol(mid + 1, r, L, cnt);
}
inline void solve() {
sol(1, n, 0, n);
for (int i = 1; i <= n; i++) writeln(ans[i]);
}
int main() {
init();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
for (long long i = 0; i < t; i++) {
long long a, b;
cin >> a >> b;
if (a <= b) {
cout << b - a << '\n';
continue;
}
if (a % b == 0) {
cout << "0\n";
continue;
}
long long c = a - a % b;
cout << b - (a - c) << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(n), b(m);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (a[n - 1] > b[0]) {
cout << -1 << endl;
return 0;
}
long long sum = 0LL;
for (int i = 0; i < m; i++) sum = sum + 1LL * b[i];
for (int i = 0; i < n - 1; i++) sum = sum + 1LL * m * a[i];
if (n > 1 && b[0] > a[n - 1]) sum = sum + a[n - 1] - a[n - 2];
cout << sum << endl;
}
| 1 |
#include <bits/stdc++.h>
int main() {
char string[101];
int i, count = 0, count1 = 0, count2 = 0;
scanf("%s", string);
for (i = 0; i < strlen(string); i++) {
if (string[i] >= 65 && string[i] <= 90) count++;
if (string[i] >= 97 && string[i] <= 122) count1++;
if (string[i] >= '0' && string[i] <= '9') count2++;
}
if (strlen(string) > 4 && count > 0 && count1 > 0 && count2 > 0)
printf("Correct");
else
printf("Too weak");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <vector>
using namespace std;
int main(){
int n,k;
cin>>n>>k;
vector <int> h(n),dp(n,INT_MAX);
for(int i=0;i<n;i++) cin>>h[i];
dp[0]=0;
for(int i=0;i<n;i++){
for(int j=1;j<=k;j++){
if(i+j<n){
dp[i+j]=min(dp[i+j],dp[i]+abs(h[i+j]-h[i]));
}
}
}
cout<<dp[n-1];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, t, b, a, p, d, g;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
cin >> t >> a >> b;
if (a == b) {
cout << "1/1";
return 0;
}
if (a > b) swap(a, b);
double r = double(gcd(a, b));
if ((double)a / r > double(t + 100) / b) {
a--;
if (a > t) {
a = t = 1;
}
g = gcd(a, t);
cout << a / g << "/" << t / g;
return 0;
}
g = a / gcd(a, b) * b;
d = (t - a + 1) / g;
p = min(t, a - 1) + d * a + max(t - d * g - g + 1, 0LL);
if (p > t) {
p = t = 1;
}
g = gcd(p, t);
cout << p / g << "/" << t / g << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 1;
const int N = 1000002;
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long power(long long A, long long B, long long mod = 1000000007) {
long long r = 1;
while (B > 0) {
if (B & 1LL) r = (r * A) % mod;
A = (A * A) % mod;
B >>= 1;
}
return r;
}
struct set_comp {
bool operator()(const int& lhs, const int& rhs) { return lhs < rhs; }
};
int a[3001];
int main() {
int n, i, j, inv = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 2; i <= n; i++) {
for (j = 1; j < i; j++) {
if (a[j] > a[i]) inv++;
}
}
double ans = 4 * (inv / 2) + inv % 2;
printf("%0.7f\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, f[100000 + 5][30 + 5];
char a[100000 + 5], b[100000 + 5];
unsigned long long ha[100000 + 5], hb[100000 + 5], p[100000 + 5];
inline void rw(int& a, int b) {
if (b > a) a = b;
}
int lcp(int x, int y) {
int l = 1, r = min(n - x + 1, m - y + 1), mid, res = 0;
while (l <= r) {
mid = l + r >> 1;
if ((ha[x + mid - 1] + hb[y - 1] * p[mid]) % 998244353 !=
(hb[y + mid - 1] + ha[x - 1] * p[mid]) % 998244353)
r = mid - 1;
else
res = mid, l = mid + 1;
}
return res;
}
int main() {
int k, i, j;
scanf("%d%s%d%s%d", &n, a + 1, &m, b + 1, &k);
for (p[0] = i = 1; i <= n; ++i)
ha[i] = (ha[i - 1] * 233 + a[i]) % 998244353,
p[i] = p[i - 1] * 233 % 998244353;
for (i = 1; i <= m; ++i) hb[i] = (hb[i - 1] * 233 + b[i]) % 998244353;
f[0][0] = 1;
for (i = 0; i < n; ++i)
for (j = 0; j <= k; ++j)
if (f[i][j]) {
rw(f[i + 1][j], f[i][j]);
int p = lcp(i + 1, f[i][j]);
rw(f[i + p][j + 1], f[i][j] + p);
}
for (i = 1; i <= k; ++i)
if (f[n][i] > m) return 0 * puts("YES");
puts("NO");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (int i = 0; i < (int)v.size(); i++) {
if (i) os << ", ";
os << v[i];
}
os << "}";
return os;
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int INF = 1.1e9;
const int N = 4e5 + 10;
template <class T>
struct rollback_array {
stack<pair<int, T>> changes;
T arr[N];
rollback_array() {}
T get(int i) { return arr[i]; }
void update(int i, T v, bool roll = 0) {
if (roll) changes.push({i, arr[i]});
arr[i] = v;
}
void click() { changes.push({INF, T()}); }
void roll_back_to_the_last_click() {
while (!changes.empty()) {
auto it = changes.top();
changes.pop();
if (it.first == INF) return;
arr[it.first] = it.second;
}
}
};
rollback_array<int> par, rnk;
int notBipartite;
void init() {
for (int i = 1; i < N; i++) {
par.update(i, 2 * i);
rnk.update(i, 1);
}
}
int root(int x) {
int ret = 0;
while (true) {
int h = par.get(x);
if (x == (h >> 1)) break;
ret ^= (h & 1);
x = h >> 1;
}
return 2 * x + ret;
}
bool merge(int x, int y, bool roll = 0) {
int X = root(x), Y = root(y);
x = X >> 1, y = Y >> 1;
int parity_x = X & 1, parity_y = Y & 1;
if (x == y) {
if (parity_x == parity_y) notBipartite = 1;
return 0;
}
int rnkx = rnk.get(x), rnky = rnk.get(y);
if (rnkx > rnky) {
swap(x, y), swap(rnkx, rnky);
swap(parity_x, parity_y);
}
int nw = 2 * y + (parity_x ^ parity_y ^ 1);
par.update(x, nw, roll);
if (rnkx == rnky) {
rnk.update(y, rnky + 1, roll);
}
return 1;
}
int a[N], b[N];
int n, m;
void click_all() {
par.click();
rnk.click();
}
void rollback_all(int notBipartite2 = 0) {
par.roll_back_to_the_last_click();
rnk.roll_back_to_the_last_click();
notBipartite = notBipartite2;
}
int fst[N];
void go(int p, int q, int l, int r) {
if (p > q) return;
int notBipartite2 = notBipartite;
click_all();
int mid = (p + q) / 2;
for (int i = mid; i <= min(q, l); i++) {
merge(a[i], b[i], 1);
}
int i = max(l, mid - 1);
for (; !notBipartite; i++) merge(a[i + 1], b[i + 1], 1);
assert(notBipartite);
assert(i <= r && i >= mid + 2);
fst[mid] = i;
rollback_all(notBipartite2);
if (p <= mid - 1) {
click_all();
for (int j = mid - 1; j <= min(l, q - 1); j++) {
merge(a[j], b[j], 1);
}
go(p, mid - 1, l, i);
rollback_all(notBipartite2);
}
if (mid + 1 <= q) {
click_all();
for (int j = max(q, l + 1); j <= i; j++) merge(a[j], b[j], 1);
go(mid + 1, q, i, r);
rollback_all(notBipartite2);
}
}
int main() {
n = 200000, m = 200000;
int q = 200000;
scanf("%d", &(n));
scanf("%d", &(m));
scanf("%d", &(q));
for (int i = 1; i <= m; i++) {
a[i] = rand() % n + 1;
b[i] = rand() % n + 1;
scanf("%d", &(a[i]));
scanf("%d", &(b[i]));
a[i + m] = a[i];
b[i + m] = b[i];
}
a[2 * m + 1] = 1, b[2 * m + 1] = 2;
a[2 * m + 2] = 2;
b[2 * m + 2] = 3;
a[2 * m + 3] = 3;
b[2 * m + 3] = 1;
init();
go(1, m + 1, 1, 2 * m + 3);
for (int i = 1; i <= q; i++) {
int l = rand() % m + 1, r = n;
scanf("%d %d", &l, &r);
printf(m > 2 && fst[r + 1] < l + m ? "YES\n" : "NO\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
typedef complex<double> Point;
typedef pair<Point, Point> Line;
typedef vector<Point> VP;
const double PI = acos(-1);
const double EPS = 1e-6; // 許容誤差^2
const double INF = 1e9;
#define X real()
#define Y imag()
// #define LE(n,m) ((n) < (m) + EPS)
#define LE(n,m) ((n) - (m) < EPS)
// #define GE(n,m) ((n) + EPS > (m))
#define GE(n,m) (EPS > (m) - (n))
#define EQ(n,m) (abs((n)-(m)) < EPS)
// 内積 dot(a,b) = |a||b|cosθ
double dot(Point a, Point b) {
return a.X*b.X + a.Y*b.Y;
}
// 外積 cross(a,b) = |a||b|sinθ
double cross(Point a, Point b) {
return a.X*b.Y - a.Y*b.X;
}
int ccw(Point a, Point b, Point c) {
b -= a; c -= a;
if (cross(b,c) > EPS) return +1; // counter clockwise
if (cross(b,c) < -EPS) return -1; // clockwise
if (dot(b,c) < -EPS) return +2; // c--a--b on line
if (norm(b) < norm(c)) return -2; // a--b--c on line or a==b
return 0; // a--c--b on line or a==c or b==c
}
// 直線と点
bool isecLP(Point a1, Point a2, Point b) {
return abs(ccw(a1, a2, b)) != 1;
// return EQ(cross(a2-a1, b-a1), 0); と等価
}
// 直線と直線
bool isecLL(Point a1, Point a2, Point b1, Point b2) {
return !isecLP(a2-a1, b2-b1, 0) || isecLP(a1, b1, b2);
}
// 2直線の交点
Point crosspointLL(Point a1, Point a2, Point b1, Point b2) {
double d1 = cross(b2-b1, b1-a1);
double d2 = cross(b2-b1, a2-a1);
if (EQ(d1, 0) && EQ(d2, 0)) return a1; // same line
assert(!EQ(d2, 0)); // 交点がない
return a1 + d1/d2 * (a2-a1);
}
// 点pの直線aへの射影点を返す
Point proj(Point a1, Point a2, Point p) {
return a1 + dot(a2-a1, p-a1)/norm(a2-a1) * (a2-a1);
}
double distLP(Point a1, Point a2, Point p) {
return abs(proj(a1, a2, p) - p);
}
Point read_p(){
int x,y;
cin >>x >>y;
return Point(x,y);
}
int main(){
int w,h,n;
double r;
while(cin >>w >>h >>n >>r,w){
vector<Line> l(n);
vector<double> t(n);
rep(i,n){
l[i].fi = read_p();
l[i].se = read_p();
cin >>t[i];
}
vector<Point> op;
op.pb({r,r});
op.pb({w-r,r});
op.pb({w-r,h-r});
op.pb({r,h-r});
vector<Line> outer;
rep(i,4) outer.pb({op[i], op[(i+1)%4]});
vector<Line> cand;
rep(i,n){
Point v = l[i].se - l[i].fi;
v = Point(v.Y, -v.X);
Point hv = v*((t[i]+r)/abs(v));
for(double j:{-1,1}){
cand.pb({l[i].fi+(hv*j), l[i].se+(hv*j)});
}
}
int C = cand.size();
VP pp(op);
rep(i,C){
Line f = cand[i];
rep(j,i){
Line g = cand[j];
if(isecLL(f.fi,f.se,g.fi,g.se)){
pp.pb(crosspointLL(f.fi,f.se,g.fi,g.se));
}
}
for(Line g:outer){
if(isecLL(f.fi,f.se,g.fi,g.se)){
pp.pb(crosspointLL(f.fi,f.se,g.fi,g.se));
}
}
}
auto IN = [&](Point p){
return LE(r,p.X) && LE(p.X,w-r) &&LE(r,p.Y) && LE(p.Y,h-r);
};
auto valid = [&](Point p){
if(!IN(p)) return false;
rep(i,n){
double d = distLP(l[i].fi, l[i].se, p);
if(t[i]+r > d+EPS) return false;
}
return true;
};
bool ans = false;
for(Point p:pp) ans |= valid(p);
cout << (ans?"Yes":"No") << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
int on(int n, int pos) { return n = n | (1 << pos); }
int dx[] = {0, 0, 1, -1};
int dy[] = {-1, 1, 0, 0};
struct node {
int fir, sec, wei, prio;
node(){};
node(int _wei, int _fir, int _sec, int _prio) {
wei = _wei;
fir = _fir;
sec = _sec;
prio = _prio;
}
bool operator<(const node& P) const {
if (prio != P.prio) return prio > P.prio;
return wei > P.wei;
}
};
int P[300000], val[300000], ans[300000], distime[300000], high[300000], id,
root, common[300000], big = 2000000;
vector<node> my;
vector<int> vc[300000], ac;
map<int, int> name[300000];
int findo(int v) {
if (P[v] == v) return v;
return P[v] = findo(P[v]);
}
void dfs_point(int v, int par) {
distime[v] = high[v] = ++id;
for (int i = 0; i < vc[v].size(); i++) {
int w = vc[v][i];
if (w == par) continue;
if (distime[w] == 0) {
dfs_point(w, v);
high[v] = min(high[w], high[v]);
if (distime[v] <= high[w] && v != root) {
name[v][w] = 1;
name[w][v] = 1;
} else if (v == root) {
ac.push_back(w);
}
} else if (distime[w] < distime[v])
high[v] = min(high[v], distime[w]);
}
if (v == root && ac.size() > 1) {
for (int i = 0; i < ac.size(); i++) {
name[root][ac[i]] = 1;
name[ac[i]][root] = 1;
}
}
}
int dec(int l, int k) {
if (val[l] == big && val[k] == big) return 1;
if (val[l] != big && val[k] != big) return 0;
if (val[k] != big) {
return common[l] == 1;
}
if (val[l] != big) {
return common[k] == 1;
}
}
int main() {
int i, j, k, l, m, n;
vector<int> worst;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
P[i] = i;
ans[i] = val[i] = 2000000;
}
vector<int> temp;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l, &k);
temp.push_back(l);
temp.push_back(k);
vc[l].push_back(k);
vc[k].push_back(l);
}
int s, d, ds, dd;
scanf("%d%d%d%d", &s, &d, &ds, &dd);
ans[s] = val[s] = ds;
ans[d] = val[d] = dd;
if (n == 2) {
printf("Yes\n");
printf("1 2\n");
return 0;
}
for (int i = 0; i < temp.size(); i += 2) {
int l = temp[i];
int k = temp[i + 1];
if (val[l] != big && val[k] != big) continue;
if (val[l] != big && val[k] == big) common[k]++;
if (val[k] != big && val[l] == big) common[l]++;
}
for (int i = 1; i <= n; i++) {
if (i != s && i != d) {
root = i;
dfs_point(i, -1);
break;
}
}
int res = 0;
for (int i = 0; i < temp.size(); i += 2) {
int l = temp[i];
int k = temp[i + 1];
int pr = name[l][k];
if (pr || dec(l, k))
my.push_back(node(val[l] + val[k], l, k, pr));
else if (!(val[l] != big && val[k] != big)) {
if (val[l] != big) swap(l, k);
worst.push_back(l);
} else {
res++;
}
}
temp.clear();
sort(my.begin(), my.end());
int cnt = 0;
for (int i = 0; i < my.size() && cnt < (n - 1); i++) {
node gr = my[i];
int p = findo(gr.fir);
int q = findo(gr.sec);
if (p == q) continue;
P[p] = q;
temp.push_back(gr.fir);
temp.push_back(gr.sec);
ans[gr.fir]--;
ans[gr.sec]--;
cnt++;
}
for (int i = 0; i < worst.size() && cnt < (n - 1); i++) {
int p = findo(s);
int q = findo(d);
int r = findo(worst[i]);
if ((p == r) || q == r) continue;
if (ans[s] > ans[d]) {
swap(s, d);
}
p = findo(d);
P[r] = p;
ans[d]--;
temp.push_back(d);
temp.push_back(worst[i]);
cnt++;
}
if (ans[d] < ans[s]) swap(d, s);
for (int i = 0; i < worst.size() && cnt < (n - 1); i++) {
int p = findo(d);
int r = findo(worst[i]);
if ((p == r)) continue;
p = findo(d);
P[r] = p;
ans[d]--;
temp.push_back(d);
temp.push_back(worst[i]);
cnt++;
}
for (int i = 0; i < worst.size() && cnt < (n - 1); i++) {
int p = findo(s);
int r = findo(worst[i]);
if ((p == r)) continue;
p = findo(s);
P[r] = p;
ans[s]--;
temp.push_back(s);
temp.push_back(worst[i]);
cnt++;
}
while (res && cnt < (n - 1)) {
int p = findo(d);
int q = findo(s);
if (p == q) break;
temp.push_back(d);
temp.push_back(s);
ans[s]--;
ans[d]--;
break;
}
if (ans[s] < 0 || ans[d] < 0) {
printf("No\n");
return 0;
}
printf("Yes\n");
for (int i = 0; i < temp.size(); i += 2) {
printf("%d %d\n", temp[i], temp[i + 1]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, m;
double ans = 0;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> m >> n;
double tmp = 0;
double last = 0;
for (int i = 1; i <= m; i++) {
tmp = pow(i / m, n);
ans += (tmp - last) * i;
last = tmp;
}
cout.setf(ios_base::fixed, ios_base::fixed);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vtype;
int modd(int& x, int& m) {
int r = x % m;
return r < 0 ? r + m : r;
}
const long long int mod = 1e9 + 7;
bool ok(long long int a, long long int b, long long int sth) {
stringstream ss;
ss << sth;
char c;
while (ss >> c) {
if (!(c - '0' == a || c - '0' == b)) return false;
}
return true;
}
long long int binPow(long long int x, long long int y) {
if (!y) return 1;
long long int p = binPow(x, y / 2) % mod;
p = (p * p) % mod;
return (y & 1) ? (x * p) % mod : p;
}
long long int fact[1000005];
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
long long int a, b, n;
cin >> a >> b >> n;
if (n == 1) {
cout << 2;
return 0;
}
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = (i * fact[i - 1]) % mod;
int aTimes;
int bTimes;
long long int val;
long long int nFact = fact[n];
long long int rFact;
long long int n_rFact;
long long int inverse;
long long int ans = 0;
for (int i = 0; i <= n; i++) {
aTimes = i;
bTimes = n - i;
val = a * aTimes + b * bTimes;
if (ok(a, b, val)) {
rFact = fact[aTimes];
n_rFact = fact[n - aTimes];
val = (rFact * n_rFact) % mod;
inverse = binPow(val, mod - 2);
ans = (ans + (nFact * inverse)) % mod;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
struct matrix {
int n, m, a[3][3];
matrix(int _n, int _m) {
n = _n;
m = _m;
memset(a, 0, sizeof(a));
}
matrix() {}
};
matrix operator*(matrix A, matrix B) {
matrix C(A.n, B.m);
for (int k = 0; k < A.m; k++)
for (int i = 0; i < A.n; i++)
for (int j = 0; j < B.m; j++)
C.a[i][j] = (1LL * C.a[i][j] + 1LL * A.a[i][k] * B.a[k][j]) %
(long long)1000000009;
return C;
}
matrix d(3, 3), I(3, 3), d1(2, 2), D[300005];
int n, m, s[300005];
int tree[300005 << 2], col1[300005 << 2], col2[300005 << 2], fib[300005];
void build(int l, int r, int rt) {
if (l == r) {
scanf("%d", &tree[rt]);
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
tree[rt] = (tree[rt << 1] + tree[rt << 1 | 1]) % 1000000009;
}
matrix PowerMod(matrix a, int b) { return D[b]; }
int calc(int s1, int s2, int l) {
matrix start(1, 2);
start.a[0][0] = s2, start.a[0][1] = s1;
start = start * PowerMod(d1, l);
int ret = (start.a[0][0] - s2) % 1000000009;
if (ret < 0) ret += 1000000009;
return ret;
}
void push_down(int rt, int l, int r) {
int m = (l + r) >> 1;
if ((!col1[rt]) && (!col2[rt])) return;
col1[rt << 1] = (col1[rt << 1] + col1[rt]) % 1000000009;
col2[rt << 1] = (col2[rt << 1] + col2[rt]) % 1000000009;
tree[rt << 1] =
(tree[rt << 1] + calc(col1[rt], col2[rt], m - l + 1)) % 1000000009;
matrix start(1, 2);
start.a[0][0] = col2[rt], start.a[0][1] = col1[rt];
start = start * PowerMod(d1, m - l + 1);
col2[rt] = start.a[0][0];
col1[rt] = start.a[0][1];
col1[rt << 1 | 1] = (col1[rt << 1 | 1] + col1[rt]) % 1000000009;
col2[rt << 1 | 1] = (col2[rt << 1 | 1] + col2[rt]) % 1000000009;
tree[rt << 1 | 1] =
(tree[rt << 1 | 1] + calc(col1[rt], col2[rt], r - m)) % 1000000009;
col1[rt] = col2[rt] = 0;
}
void insert(int ll, int rr, int s, int l, int r, int rt) {
if (ll <= l && r <= rr) {
s += l - ll;
col1[rt] = (col1[rt] + fib[s]) % 1000000009;
col2[rt] = (col2[rt] + fib[s + 1]) % 1000000009;
tree[rt] = (tree[rt] + calc(fib[s], fib[s + 1], r - l + 1)) % 1000000009;
return;
}
int m = (l + r) >> 1;
push_down(rt, l, r);
if (ll <= m) insert(ll, rr, s, l, m, rt << 1);
if (m < rr) insert(ll, rr, s, m + 1, r, rt << 1 | 1);
tree[rt] = (tree[rt << 1] + tree[rt << 1 | 1]) % 1000000009;
}
int query(int ll, int rr, int l, int r, int rt) {
if (ll <= l && r <= rr) {
return tree[rt];
}
int m = (l + r) >> 1;
push_down(rt, l, r);
int ret = 0;
if (ll <= m) ret = (ret + query(ll, rr, l, m, rt << 1)) % 1000000009;
if (m < rr) ret = (ret + query(ll, rr, m + 1, r, rt << 1 | 1)) % 1000000009;
return ret;
}
int getint() {
int ret = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while ('0' <= c && c <= '9') ret = ret * 10 + c - '0', c = getchar();
return ret;
}
int main() {
n = getint(), m = getint();
build(1, n, 1);
d.a[0][0] = 1;
d.a[0][1] = 0;
d.a[0][2] = 0;
d.a[1][0] = 0;
d.a[1][1] = 0;
d.a[1][2] = 1;
d.a[2][0] = 1;
d.a[2][1] = 1;
d.a[2][2] = 1;
I.a[0][0] = 1;
I.a[1][1] = 1;
I.a[2][2] = 1;
d1.a[0][0] = 1, d1.a[0][1] = 1, d1.a[1][0] = 1;
fib[1] = 1, fib[2] = 1;
D[0] = matrix(2, 2);
D[0].a[0][0] = D[0].a[1][1] = 1;
for (int i = 1; i <= n + 1; i++) D[i] = D[i - 1] * d1;
for (int i = 3; i <= n + 1; i++)
fib[i] = (fib[i - 1] + fib[i - 2]) % 1000000009;
for (int i = 0; i < m; i++) {
int type, l, r;
type = getint();
l = getint();
r = getint();
if (type == 1)
insert(l, r, 1, 1, n, 1);
else
printf("%d\n", query(l, r, 1, n, 1));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int arr[100001];
int n, k, total = 1;
void reverseMerge(int start, int end) {
if (total == k || start + 1 == end) return;
int mid = (end + start) / 2;
if (mid - 1 < start) return;
int temp = arr[mid];
arr[mid] = arr[mid - 1];
arr[mid - 1] = temp;
total += 2;
reverseMerge(start, mid);
reverseMerge(mid, end);
}
void solve() {
scanf("%d %d", &n, &k);
if (k % 2 == 0) {
printf("-1\n");
return;
}
for (int i = 0; i < n; i++) arr[i] = i + 1;
reverseMerge(0, n);
if (total != k) {
printf("-1");
return;
}
for (int i = 0; i < n; i++) printf("%d ", arr[i]);
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
inline char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
const int N = 200010;
int n, m, i, j, k, l, p, x;
pair<int, int> a[N];
int T, cnt[N];
long long ans, tot;
int c[N], d[N];
long long pow(long long a, long long b, long long c) {
long long ans = 1;
for (a %= c; b; b >>= 1, a = a * a % c)
if (b & 1) ans = ans * a % c;
return ans;
}
int main() {
read(n);
for (i = 1; i <= n; i++) read(x), a[i] = make_pair(x, i);
for (i = 1; i <= n; i++) read(x), a[n + i] = make_pair(x, i);
read(m);
n *= 2;
for (i = 2; i <= n; i++)
if (!d[i])
for (j = 2; j <= n / i; j++) d[i * j] = i;
sort(a + 1, a + 1 + n);
ans = 1;
for (i = 1; i <= n; i = j + 1) {
for (j = i; j <= n && a[j].first == a[i].first; j++)
;
j--;
T++;
int tot = 0;
for (k = i; k <= j; k++) {
if (cnt[a[k].second] != T)
cnt[a[k].second] = T;
else
tot++;
}
for (k = 1; k <= j - i + 1; k++) c[k]++;
c[2] -= tot;
}
for (i = n; i >= 2; i--) {
if (d[i] == 0)
ans = ans * pow(i, c[i], m) % m;
else {
c[d[i]] += c[i];
c[i / d[i]] += c[i];
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100;
char s[MAX_N + 4];
int hls[MAX_N], vls[MAX_N];
int main() {
int n;
scanf("%d", &n);
memset(hls, -1, sizeof(hls));
memset(vls, -1, sizeof(vls));
for (int y = 0; y < n; y++) {
scanf("%s", s);
for (int x = 0; x < n; x++)
if (s[x] == '.') hls[y] = x, vls[x] = y;
}
bool ok = true;
for (int y = 0; ok && y < n; y++) ok = (hls[y] >= 0);
if (ok) {
for (int y = 0; y < n; y++) printf("%d %d\n", y + 1, hls[y] + 1);
return 0;
}
ok = true;
for (int x = 0; ok && x < n; x++) ok = (vls[x] >= 0);
if (ok) {
for (int x = 0; x < n; x++) printf("%d %d\n", vls[x] + 1, x + 1);
return 0;
}
puts("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 205;
int q, n, a[maxn], cnt[maxn];
int main() {
scanf("%d", &q);
while (q--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
int tmp = a[i], cn = 1;
while (i != tmp) {
tmp = a[tmp];
cn++;
}
cnt[i] = cn;
}
for (int i = 1; i <= n; i++) printf("%d ", cnt[i]);
puts("");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
struct str {
int ID;
int d;
};
str a[1000];
bool comp(str a, str b) { return (a.d < b.d); }
int main() {
int cnt = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
a[i].ID = i + 1;
cin >> a[i].d;
}
sort(a, a + n, comp);
int p = 0;
while (p < k) {
if (p + a[cnt].d > k || cnt == n) {
break;
}
p += a[cnt].d;
cnt += 1;
}
cout << cnt << endl;
for (int i = 0; i < cnt; i++) cout << a[i].ID << " ";
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 45000;
int maxv[maxn * 4];
int add[maxn * 4];
int a[maxn], last[maxn], now[maxn];
int dp[maxn][55];
void pushUp(int rt) { maxv[rt] = max(maxv[rt * 2], maxv[rt * 2 + 1]); }
void pushDown(int rt) {
if (add[rt]) {
add[rt * 2] += add[rt];
add[rt * 2 + 1] += add[rt];
maxv[rt * 2] += add[rt];
maxv[rt * 2 + 1] += add[rt];
add[rt] = 0;
}
}
void update(int x, int y, int c, int l, int r, int rt) {
if (x <= l && y >= r) {
maxv[rt] += c;
add[rt] += c;
return;
}
pushDown(rt);
int m = (l + r) / 2;
if (x <= m) update(x, y, c, l, m, rt * 2);
if (y > m) update(x, y, c, m + 1, r, rt * 2 + 1);
pushUp(rt);
}
int query(int x, int y, int l, int r, int rt) {
if (x <= l && y >= r) {
return maxv[rt];
}
pushDown(rt);
int m = (l + r) / 2;
int ret = 0;
if (x <= m) ret = max(ret, query(x, y, l, m, rt * 2));
if (y > m) ret = max(ret, query(x, y, m + 1, r, rt * 2 + 1));
return ret;
}
int main() {
int n, k, i, j;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(now, 0, sizeof(now));
for (i = 1; i <= n; i++) {
last[i] = now[a[i]];
now[a[i]] = i;
}
memset(dp, 0, sizeof(dp));
for (j = 1; j <= k; j++) {
memset(maxv, 0, sizeof(maxv));
memset(add, 0, sizeof(add));
for (i = 1; i <= n; i++) update(i, i, dp[i][j - 1], 0, n, 1);
for (int i = j; i <= n; i++) {
update(max(last[i], j - 1), i - 1, 1, 0, n, 1);
dp[i][j] = query(j - 1, i - 1, 0, n, 1);
}
}
printf("%d\n", dp[n][k]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int BinSea(vector<long long int>& a, long long int low,
long long int high, long long int n) {
long long int ct = high;
long long int ans = high;
while (low <= high) {
long long int mid = low + ((high - low) / 2);
long long int val = a[ct] - a[mid];
if (val <= n) {
ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return ans;
}
int main() {
long long int n, k;
cin >> n >> k;
vector<long long int> a(2 * n + 1);
vector<long long int> p1(2 * n + 1), p2(2 * n + 1);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
a[n + i] = a[i];
}
long long int v1 = 0, v2 = 0;
for (long long int i = 0; i < 2 * n; i++) {
v1 += (a[i] * (a[i] + 1)) / 2;
v2 += a[i];
p1[i] = v1;
p2[i] = v2;
}
long long int mx = 0;
for (long long int i = 2 * n - 1; i > n - 1; i--) {
long long int val = BinSea(p2, 0, i, k);
long long int fullmt = p1[i] - p1[val];
long long int remdy = a[val] - (k - (p2[i] - p2[val]));
long long int sumrem = remdy * (remdy + 1) / 2;
long long int sum = a[val] * (a[val] + 1) / 2;
fullmt += (sum - sumrem);
mx = max(mx, fullmt);
}
cout << mx << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[100], arrr[100], o;
cin >> o;
for (int i = 0; i < o; i++) {
cin >> arr[i];
}
for (int l = 0; l < o; l++) {
int k = 0, s = 0;
for (int i = 0; i < o; i++) {
if (arr[l] > arr[i]) {
k += 1;
} else if (arr[l] == arr[i]) {
s += 1;
}
}
s -= 1;
if (s >= 1) {
for (int p = 1; p <= s; p++) {
arrr[k + p] = arr[l];
arrr[k] = arr[l];
}
} else {
arrr[k] = arr[l];
}
}
for (int i = 0; i < o; i++) {
cout << arrr[i] << ' ';
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e5) + 50, MXP = 120;
long double f[N][MXP], tmp[MXP];
int n, cnt[N];
inline long double C(int u, int v) {
long double res = 1;
for (int i = 0; i < v; ++i) res = res * (u - i) / (i + 1);
return res;
}
int main() {
scanf("%d", &n);
long double res = 0.0;
for (int i = 1; i <= n; ++i) {
scanf("%d", cnt + i);
f[i][cnt[i]] = 1;
res += f[i][0];
}
int q, u, v, k;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &u, &v, &k);
res -= f[u][0];
for (int i = 0; i <= cnt[u] && i < MXP; ++i) {
tmp[i] = 0;
for (int j = 0; j <= k && i + j <= cnt[u] && i + j < MXP; ++j)
tmp[i] +=
f[u][i + j] * C(i + j, j) * C(cnt[u] - i - j, k - j) / C(cnt[u], k);
}
cnt[u] -= k;
cnt[v] += k;
for (int i = 0; i <= cnt[u] && i < MXP; ++i) f[u][i] = tmp[i];
for (int i = cnt[u] + 1; i < MXP; ++i) f[u][i] = 0;
long double tmpc = 0;
for (int i = 0; i < MXP; ++i) tmpc += f[u][i];
if (fabs(tmpc - 1.0) > 1e-6) throw;
res += f[u][0];
printf("%.11f\n", double(res));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
const int MAXN = 3e5 + 10;
struct segment_tree {
using dtype = int;
int _l, _r, _start_node;
inline dtype op(dtype& lhs, dtype& rhs) { return max(lhs, rhs); }
dtype _null_val;
dtype a[MAXN] = {};
dtype tree[MAXN * 4] = {}, lazy[MAXN * 4] = {};
void push(int l, int r, int node) {
if (lazy[node] != 0) {
tree[node * 2] += lazy[node];
lazy[node * 2] += lazy[node];
tree[node * 2 + 1] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
lazy[node] = 0;
}
}
void build(int l, int r, int node) {
if (l == r)
tree[node] = a[l];
else {
int mid = l + (r - l) / 2;
build(l, mid, node * 2);
build(mid + 1, r, node * 2 + 1);
tree[node] = op(tree[node * 2], tree[node * 2 + 1]);
}
}
void update(dtype v, int left, int right, int l, int r, int node) {
if (left > right) return;
if (right < l || r < left) return;
if (left <= l && r <= right) {
tree[node] += v;
lazy[node] += v;
} else {
push(l, r, node);
int mid = l + (r - l) / 2;
update(v, left, right, l, mid, node * 2);
update(v, left, right, mid + 1, r, node * 2 + 1);
tree[node] = op(tree[node * 2], tree[node * 2 + 1]);
}
}
dtype query(int left, int right, int l, int r, int node) {
if (left > right) return _null_val;
if (right < l || r < left) return _null_val;
if (left <= l && r <= right) return tree[node];
push(l, r, node);
int mid = l + (r - l) / 2;
dtype r1 = query(left, right, l, mid, node * 2);
dtype r2 = query(left, right, mid + 1, r, node * 2 + 1);
return op(r1, r2);
}
void set(int l, int r, const dtype& null_val) {
_l = l;
_r = r;
_start_node = 1;
_null_val = null_val;
if (null_val)
for (int i = l; i <= r; i++) a[i] = null_val;
}
dtype& operator[](int idx) { return a[idx]; }
void build() { build(_l, _r, _start_node); }
void update(dtype v, int left, int right) {
return update(v, left, right, _l, _r, _start_node);
}
dtype query(int left, int right) {
return query(left, right, _l, _r, _start_node);
}
} segt1, segt2;
int p[MAXN], q[MAXN];
void solve(int tt) {}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
unordered_map<int, int> make_pair;
for (auto i = (1); i < (n + 1); i++) {
cin >> p[i];
make_pair[p[i]] = i;
}
for (auto i = (1); i < (n + 1); i++) cin >> q[i];
segt1.set(1, n, 0);
for (auto i = (1); i < (n + 1); i++) segt1[i] = p[i];
segt1.build();
segt2.set(1, n, 0);
segt2.build();
cout << n << ' ';
set<int> es;
for (auto i = (1); i < (n + 1); i++) es.insert(i);
for (auto i = (1); i < (n); i++) {
segt2.update(1, q[i], n);
int lo = 1, hi = n + 1, mid;
while (lo < hi) {
mid = lo + (hi - lo) / 2;
if (segt2.query(1, mid) >= 1)
hi = mid;
else
lo = mid + 1;
}
int pp = segt1.query(1, lo);
int idx = make_pair[pp];
segt1.update(-pp, idx, idx);
es.erase(pp);
segt2.update(-1, idx, n);
cout << *prev(es.end()) << ' ';
}
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 1e6 + 10;
int n;
long long k;
char s[N], t[N];
int main() {
scanf("%d%lld%s%s", &n, &k, s + 1, t + 1);
long long ans = 0, tot = 1, INF = 1e15;
for (int i = 1; i <= n; ++i) {
tot <<= 1;
if (s[i] == 'b') --tot;
if (t[i] == 'a') --tot;
ans += min(k, tot);
tot = min(tot, INF);
}
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long c[3][100005], a1[100005], a2[100005], a3[100005];
long long calc[100005];
long long solve() {
long long n, q;
cin >> n >> q;
long long debris = 0;
while (q--) {
long long t1, t2;
cin >> t1 >> t2;
if (c[t1][t2]) {
if (t1 == 1) {
if (c[1][t2] && c[2][t2]) debris--;
if (c[1][t2] && c[2][t2 + 1] && t2 + 1 <= n) debris--;
if (c[1][t2] && c[2][t2 - 1] && t2 - 1 >= 1) debris--;
} else {
if (c[2][t2] && c[1][t2]) debris--;
if (c[2][t2] && c[1][t2 + 1] && t2 + 1 <= n) debris--;
if (c[2][t2] && c[1][t2 - 1] && t2 - 1 >= 1) debris--;
}
c[t1][t2] = 0;
} else {
c[t1][t2] = 1;
if (t1 == 1) {
if (c[1][t2] && c[2][t2]) debris++;
if (c[1][t2] && c[2][t2 + 1] && t2 + 1 <= n) debris++;
if (c[1][t2] && c[2][t2 - 1] && t2 - 1 >= 1) debris++;
} else {
if (c[2][t2] && c[1][t2]) debris++;
if (c[2][t2] && c[1][t2 + 1] && t2 + 1 <= n) debris++;
if (c[2][t2] && c[1][t2 - 1] && t2 - 1 >= 1) debris++;
}
}
if (!debris)
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
signed main() {
ios::sync_with_stdio(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
char a[200310], b[200310];
long long sum[200310];
long long Solve(int len1, int len2) {
long long ans = 0;
for (int i = 0; i < len2; i++) {
int l, r;
if (i + 1 >= len1)
r = len1;
else
r = i + 1;
if (i + 1 >= len1) {
if (i + len1 <= len2)
l = 1;
else
l = i + 1 - (len2 - len1);
} else {
if (len2 - len1 >= i + 1)
l = 1;
else
l = i + 1 - (len2 - len1);
}
if (b[i] == '1')
ans += (r - l + 1) - (sum[r] - sum[l - 1]);
else
ans += sum[r] - sum[l - 1];
}
return ans;
}
int main() {
while (scanf("%s %s", a, b) != EOF) {
int len1 = strlen(a);
int len2 = strlen(b);
memset(sum, 0, sizeof(sum));
for (int i = 0; i < len1; i++) sum[i + 1] = sum[i] + a[i] - '0';
long long ans = Solve(len1, len2);
printf("%I64d\n", ans);
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, x, ans;
int a[33][33], b[33][33], p[33];
int main() {
scanf("%d", &N);
x = (N + 1) / 2;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) scanf("%d", &a[i][j]);
ans = -0x3f3f3f3f;
for (int s = 0; s < (1 << x); s++) {
memcpy(b, a, sizeof(b));
for (int i = 0; i < x; i++)
if (s & (1 << i)) {
for (int j = 0; j < x; j++)
for (int k = 0; k < x; k++) {
b[i + j][x - 1 + k] *= -1;
}
}
int cur = 0;
for (int i = 0; i < N; i++) cur += b[i][x - 1];
for (int j = 0; j < x - 1; j++) {
for (int i = 0; i < N; i++) p[i] = b[i][j] + b[i][j + x];
int s1 = p[x - 1], s2 = -p[x - 1];
for (int i = 0; i < x - 1; i++) {
s1 += abs(p[i] + p[i + x]);
s2 += abs(p[i] - p[i + x]);
}
cur += max(s1, s2);
}
ans = max(ans, cur);
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2,no-stack-protector,unroll-loops,fast-math")
const long long maxn = 2e5 + 10, maxm = 5e2 + 10, lg = 21, mod = 1e9 + 7,
inf = 1e18;
long long n, q;
struct node {
long long sum = 0, e = 0, o = 0, lz = 0;
} seg[maxn << 2];
node mrg(long long s, long long mid, long long t, node l, node r) {
node ret;
if ((mid - s) % 2 == 0) {
ret.o = min(l.o, r.o - l.sum);
ret.e = min(l.e, r.e + l.sum);
} else {
ret.o = min(l.o, r.e + l.sum);
ret.e = min(l.e, r.o - l.sum);
}
ret.sum = r.sum;
if ((t - mid) % 2 == 0)
ret.sum += l.sum;
else
ret.sum -= l.sum;
return ret;
}
void app(long long s, long long t, long long v, long long x) {
seg[v].o += x;
seg[v].lz += x;
if ((t - s) % 2) seg[v].sum += x;
}
void shift(long long s, long long t, long long v) {
if (seg[v].lz == 0) return;
app(s, ((s + t) >> 1), (v << 1), seg[v].lz);
app(((s + t) >> 1), t, ((v << 1) ^ 1), seg[v].lz);
seg[v].lz = 0;
}
void add(long long l, long long r, long long x, long long s = 0,
long long t = n, long long v = 1) {
if (l >= t || r <= s) return;
if (l <= s && r >= t) return app(s, t, v, x);
shift(s, t, v);
add(l, r, x, s, ((s + t) >> 1), (v << 1));
add(l, r, x, ((s + t) >> 1), t, ((v << 1) ^ 1));
seg[v] = mrg(s, ((s + t) >> 1), t, seg[(v << 1)], seg[((v << 1) ^ 1)]);
}
node get(long long l, long long r, long long s = 0, long long t = n,
long long v = 1) {
if (l <= s && r >= t) return seg[v];
shift(s, t, v);
if (r <= ((s + t) >> 1)) return get(l, r, s, ((s + t) >> 1), (v << 1));
if (l >= ((s + t) >> 1)) return get(l, r, ((s + t) >> 1), t, ((v << 1) ^ 1));
return mrg(max(s, l), ((s + t) >> 1), min(t, r),
get(l, r, s, ((s + t) >> 1), (v << 1)),
get(l, r, ((s + t) >> 1), t, ((v << 1) ^ 1)));
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0, x; i < n; i++) {
cin >> x;
add(i, i + 1, x);
}
cin >> q;
while (q--) {
long long ty, l, r;
cin >> ty >> l >> r;
if (ty == 1) {
long long x;
cin >> x;
add(l, ++r, x);
} else {
node x = get(l, ++r);
cout << (x.o >= 1 && x.e >= 0 && x.sum == (r - l) % 2 ? 1 : 0) << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, a, b;
cin >> x >> a >> b;
puts(abs(x-a)<abs(x-b)?"A":"B");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mypow(long long a, long long b, long long mod) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
int a[1000010];
int c[1000010];
long long d[1000010];
inline bool cmp(int a, long long b, int c, long long d) {
return b * c >= d * a;
}
int read() {
int s = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
signed main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
a[i] = read();
}
int p = 0;
for (int i = 1; i <= n; i++) {
c[++p] = 1;
d[p] = a[i];
while (p >= 2 && cmp(c[p - 1], d[p - 1], c[p], d[p])) {
c[p - 1] += c[p];
d[p - 1] += d[p];
p--;
}
}
for (int i = 1; i <= p; i++) {
double tmp = (double)d[i] / c[i];
for (int j = 1; j <= c[i]; j++) {
printf("%.9lf\n", tmp);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){string s; cin>>s;cout<<s[0]<<s.size()-2<<s[s.size()-1]<<"\n";return 0;}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 500;
const int maxm = 500000 + 10;
struct Edge {
int next, v;
Edge() {}
Edge(int next, int v) : next(next), v(v) {}
} e[maxm << 1];
int n, m, len, timer, num;
int head[maxm], cnt;
int low[maxn], dfn[maxn], belo[maxn];
bool inst[maxn], used[maxn];
int st[maxm], top, q[maxm], front, tail;
char org[27], s[maxn], ans[maxn], res[maxn];
int val[128];
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
inline void AddEdge(int u, int v) {
e[++cnt] = Edge(head[u], v);
head[u] = cnt;
}
void tarjan(int u) {
low[u] = dfn[u] = ++timer;
st[++top] = u;
inst[u] = 1;
for (int i = head[u]; i; i = e[i].next) {
int v = e[i].v;
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (inst[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
num++;
int j;
do {
j = st[top--];
belo[j] = num;
inst[j] = 0;
} while (j != u);
}
}
inline bool judge(int n) {
for (int i = 2; i <= (n << 1 | 1); i++)
if (!dfn[i]) tarjan(i);
for (int i = 2; i <= (n << 1); i += 2)
if (belo[i] == belo[i + 1]) return 0;
return 1;
}
inline char find(int pos, char c) {
for (int i = pos + 1; i < len; i++)
if (org[i] == c) return 'a' + i;
return -1;
}
int main() {
scanf("%s", org);
len = strlen(org);
for (int i = 0; i < len; i++) val[i + 'a'] = org[i] == 'V' ? 0 : 1;
n = read(), m = read();
char op1[10], op2[10];
int a, b;
while (m--) {
a = read(), scanf("%s", op1);
b = read(), scanf("%s", op2);
a = a << 1 | (op1[0] != 'V');
b = b << 1 | (op2[0] != 'V');
AddEdge(a, b);
AddEdge(b ^ 1, a ^ 1);
}
scanf("%s", s + 1);
if (!judge(n)) {
puts("-1");
return 0;
}
bool exis = 0;
res[1] = -1;
for (int pos = n + 1; pos >= 1; pos--) {
for (int a = pos << 1; a <= (pos << 1 | 1); a++) {
strcpy(ans + 1, s + 1);
if (pos <= n) {
char tp = find(s[pos] - 'a', a & 1 ? 'V' : 'C');
if (tp == -1) continue;
ans[pos] = tp;
}
for (int i = pos + 1; i <= n; i++) ans[i] = 'a';
bool flag = 1;
memset(used, 0, sizeof(used));
for (int i = 1, x; i <= n && flag; i++) {
x = i << 1 | val[ans[i]];
if (used[x]) continue;
used[x] = 1;
front = tail = 0;
q[++tail] = x;
while (front != tail) {
x = q[++front];
if (used[x ^ 1]) {
flag = 0;
break;
}
if ((x >> 1) <= pos && val[ans[x >> 1]] != (x & 1)) {
flag = 0;
break;
}
if ((x >> 1) > pos) {
char tp = find(-1, x & 1 ? 'C' : 'V');
if (tp == -1) {
flag = 0;
break;
}
ans[x >> 1] = tp;
}
for (int j = head[x]; j; j = e[j].next) {
int v = e[j].v;
if (!used[v]) {
used[v] = 1;
q[++tail] = v;
}
}
}
}
if (!flag) continue;
exis = 1;
ans[n + 1] = '\0';
if (res[1] == -1)
strcpy(res + 1, ans + 1);
else if (strcmp(res + 1, ans + 1) > 0)
strcpy(res + 1, ans + 1);
}
if (exis) break;
}
if (exis)
puts(res + 1);
else
puts("-1");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 20;
const int MAXD = 7005;
struct seg {
int l, r, x;
seg(int l, int r, int x) : l(l), r(r), x(x) {}
bool intersect(int L, int R) {
if (R < l || L > r) return 0;
return 1;
}
};
int n, m;
int cnt[MAXD];
vector<seg> L[MAXD];
int ans = 0;
int cookie;
int bio[MAXN];
void add(int x) {
if (bio[x] == cookie) return;
++ans;
bio[x] = cookie;
}
int left_of_me(int x) {
int ret = x;
while ((x & -x) != x) x -= x & -x;
--x;
return ret + __builtin_popcount(x);
}
int left(int x) {
int idx = left_of_me(x);
if ((x & -x) != x) ++idx;
return idx;
}
int right(int x) {
int idx = left(x);
if ((x & -x) == x) ++idx;
return idx;
}
void dfs(int t, int l, int r) {
for (int i = 0; i < L[t].size(); ++i)
if (L[t][i].intersect(l, r)) add(L[t][i].x);
if (t == n) return;
dfs(t + 1, left(l), right(r));
}
int main(void) {
scanf("%d%d", &n, &m);
cnt[1] = 1;
for (int i = 1; i < n; ++i) {
cnt[i + 1] = 0;
for (int j = 1; j <= cnt[i]; ++j) {
if ((j & -j) == j) ++cnt[i + 1];
++cnt[i + 1];
}
}
for (int i = 0; i < m; ++i) {
int tip;
scanf("%d", &tip);
if (tip == 1) {
int t, l, r, x;
scanf("%d%d%d%d", &t, &l, &r, &x);
L[t].push_back(seg(l, r, x));
}
if (tip == 2) {
int t, x;
scanf("%d%d", &t, &x);
ans = 0;
++cookie;
dfs(t, x, x);
printf("%d\n", ans);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 0, k = 0, a;
cin >> n;
int b[n];
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) s += b[i];
int q = 0, s2;
if (s % 2 == 0)
s2 = s / 2;
else
s2 = s / 2 + 1;
for (int i = 0; i < n; i++) {
k += b[i];
q++;
if (k >= s2) break;
}
cout << q;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int maxn = 105;
using namespace std;
int pos[maxn];
int main() {
int n, m, k;
while (scanf("%d %d %d", &n, &m, &k) != EOF) {
for (int i = 1; i <= n; ++i) {
scanf("%d", &pos[i]);
}
int left = m - 1, right = m + 1;
int ans;
while (1) {
if (left >= 1 && pos[left] <= k && pos[left] != 0) {
ans = (m - left) * 10;
break;
}
if (right <= n && pos[right] <= k && pos[right] != 0) {
ans = (right - m) * 10;
break;
}
--left;
++right;
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c,d;
cin >> a >> b >> c >> d;
if(a+b+c+d==21 && a*b*c*d==252) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, flag = 1, now = 0;
cin >> n;
int a[109];
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i > 1 && flag) {
if (a[i] > a[i - 1]) {
if (now != 0 && now != 1)
flag = 0;
else
now = 1;
}
if (a[i] == a[i - 1]) {
if (now != 0 && now != 1 && now != 2)
flag = 0;
else
now = 2;
}
if (a[i] < a[i - 1]) {
now = 3;
}
}
}
if (!flag)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = (1 << 18) + 5, mod = 31, bit = 60;
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, m, k, t, pro = 1, temp, i, j, l, r, x, y, z, mid, rem,
carry = 0, ind, ans = 0, mx = -LONG_LONG_MAX,
mn = LONG_LONG_MAX, cnt = 0, curr = 0, prev, next,
sum = 0, i1 = -1, i2 = -1;
bool flag;
cin >> n;
long long int a[n + 1];
for (i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == -1) {
for (j = 1; j <= i; j++) {
a[j] = 0;
}
}
}
priority_queue<long long int, vector<long long int>, greater<long long int>>
pq;
for (i = n; i >= 1; i--) {
pq.push(a[i]);
if ((i & (i - 1)) == 0) {
ans += pq.top();
pq.pop();
}
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
set<int> st;
for (int i = 0; i < n; i++)
{
int a;
cin >> a;
st.insert(a);
}
if((int)st.size()==n) puts("YES");
else puts("NO");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100009];
int n;
bool good(int len) {
multiset<int> ms;
for (int i = 1; i <= len; ++i) ms.insert(a[i]);
for (int st = 1; st + len - 1 <= n; ++st) {
auto mn = ms.begin();
auto mx = ms.end();
--mx;
if ((*mx - *mn) <= 1) return true;
ms.erase(ms.find(a[st]));
ms.insert(a[st + len]);
}
return false;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
int lo = 1, hi = n;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
if (good(mid))
lo = mid;
else
hi = mid - 1;
}
cout << lo << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int h,w,n;
vector<string> mp(31);
vector<string> tmp;
bool cal(){
bool f=1;
while(f){
f=0;
for(int i=0;i<w;i++)
for(int j=1;j<h;j++)
for(int k=j;k>0;k--)
if(mp[k][i]=='.'&&mp[k-1][i]!='.')swap(mp[k][i],mp[k-1][i]),f=1;
bool used[30][30]={};
for(int i=0;i<h;i++){
int c=1,p=0;
for(int j=1;j<=w;j++)
if(mp[i][p]==mp[i][j])c++;
else if(c<n)c=1,p=j;
else {
for(int k=0;k<c;k++)used[i][p+k]=1;
c=1,p=j;
}
}
for(int i=0;i<w;i++){
int c=1,p=0;
for(int j=1;j<=h;j++)
if(mp[p][i]==mp[j][i])c++;
else if(c<n)c=1,p=j;
else {
for(int k=0;k<c;k++)used[p+k][i]=1;
c=1,p=j;
}
}
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)if(used[i][j])mp[i][j]='.';
for(int i=0;i<w;i++)
for(int j=1;j<h;j++)
for(int k=j;k>0;k--)
if(mp[k][i]=='.'&&mp[k-1][i]!='.')swap(mp[k][i],mp[k-1][i]),f=1;
}
bool res=1;
for(int i=0;i<w;i++)res&=mp[h-1][i]=='.';
return res;
}
bool solve(int x,int y){
mp=tmp;
if(x+1<w)swap(mp[y][x],mp[y][x+1]);
return cal();
}
int main(){
cin>>h>>w>>n;
for(int i=0;i<h;i++)cin>>mp[i],mp[i]+='?';
mp[h]="???????????????????????????????";
tmp=mp;
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)
if(solve(j,i)){cout<<"YES"<<endl;return 0;}
cout<<"NO"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<string> all[1000010][5];
vector<string> v;
int ids(char c) {
return c == 'a' ? 0
: c == 'e' ? 1
: c == 'i' ? 2
: c == 'o' ? 3
: c == 'u' ? 4
: -1;
}
char buf[1000010];
string read() {
scanf("%s", buf);
return buf;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
string s = read();
int cnt = 0;
for (int j = 0; j < s.length(); j++) {
if (~ids(s[j])) cnt++;
}
int last;
for (int j = (int)s.length() - 1; j >= 0; j--) {
last = ids(s[j]);
if (~last) break;
}
all[cnt][last].push_back(s);
}
for (int i = 1; i <= 1000000; i++) {
int cnt = 0;
for (int j = 0; j < 5; j++) {
if (all[i][j].size() & 1)
v.push_back(all[i][j].back()), all[i][j].pop_back(), cnt++;
}
if (cnt & 1) v.pop_back();
}
int tot1 = v.size() / 2, tot2 = 0;
for (int i = 1; i <= 1000000; i++) {
for (int j = 0; j < 5; j++) {
tot2 += all[i][j].size() / 2;
}
}
int ans;
if (tot2 <= tot1)
ans = tot2, tot1 = 0;
else
ans = (tot1 + tot2) / 2, tot1 = (ans - tot1) * 2;
for (int i = 1; i <= 1000000; i++) {
for (int j = 0; j < 5; j++) {
while (all[i][j].size() && tot1) {
v.push_back(all[i][j].back()), all[i][j].pop_back();
v.push_back(all[i][j].back()), all[i][j].pop_back();
tot1 -= 2;
}
}
}
printf("%d\n", ans);
for (int i = 1; i <= 1000000; i++) {
for (int j = 0; j < 5; j++) {
for (int k = 0; ans > 0 && k + 1 < all[i][j].size(); k += 2) {
string a = v.back();
v.pop_back();
string b = v.back();
v.pop_back();
printf("%s %s\n%s %s\n", a.c_str(), all[i][j][k].c_str(), b.c_str(),
all[i][j][k + 1].c_str());
ans--;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100;
char a[maxn + 10][maxn + 10];
vector<pair<int, int> > col, row;
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i][j] != 'E') {
col.push_back(make_pair(i, j));
j = n + 1;
}
for (int j = 0; j < n; j++)
for (int i = 0; i < n; i++)
if (a[i][j] != 'E') {
row.push_back(make_pair(i, j));
i = n + 1;
}
if (row.size() != n && col.size() != n)
cout << -1 << endl;
else {
if (row.size() == n)
for (int i = 0; i < n; i++)
cout << row[i].first + 1 << " " << row[i].second + 1 << endl;
else
for (int i = 0; i < n; i++)
cout << col[i].first + 1 << " " << col[i].second + 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int t = a;
while (b != 0) {
t = a;
a = b;
b = t % a;
}
return a;
}
int main() {
int a, b;
cin >> a >> b;
long long c = 1LL * a / gcd(a, b) * b;
int x = (c - 1) / a + (a > b), y = (c - 1) / b + (b > a);
if (x == y)
cout << "Equal" << endl;
else if (x > y)
cout << "Dasha" << endl;
else
cout << "Masha" << endl;
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.