solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long mon;
long long t;
};
long long w[300010], ans[300010];
priority_queue<node> q;
bool operator<(node a, node b) {
if (a.mon != b.mon) return a.mon < b.mon;
return a.t > b.t;
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> w[i];
}
long long cnt = 1, sum = 0;
for (int i = k + 1; i <= k + n; i++) {
while (cnt <= min(i, n)) {
node x;
x.mon = w[cnt];
x.t = cnt;
q.push(x);
cnt++;
}
node x = q.top();
q.pop();
ans[x.t] = i;
sum += x.mon * (i - x.t);
}
cout << sum << endl;
for (int i = 1; i <= n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
const int INF = 1000000007;
const int MOD = 1000000007;
const long long LLNF = (long long)10e17 + 7;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <typename T>
ostream& operator<<(ostream& is, vector<T>& v) {
for (auto& i : v) is << i << " ";
return is;
}
void ff() { fflush(stdout); }
void IO(string name = "") {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if ((int)(name).size()) {
freopen((name + ".in").c_str(), "r", stdin);
freopen((name + ".out").c_str(), "w", stdout);
}
}
struct pred {
bool operator()(const std::pair<int, int>& l, const std::pair<int, int>& r) {
return l.second < r.second;
}
};
int ans[5005];
int main() {
IO();
int n;
cin >> n;
vector<int> a(n);
for (int i = (0); i < (n); ++i) {
int x;
cin >> x;
a[i] = x;
}
for (int i = (0); i < (n); ++i) {
vector<int> cur(n + 1);
int best = 0;
for (int j = (i); j < (n); ++j) {
++cur[a[j]];
if (cur[a[j]] > cur[best] || cur[a[j]] == cur[best] && a[j] < best)
best = a[j];
++ans[best];
}
}
for (int i = (1); i < (n + 1); ++i) cout << ans[i] << " ";
cout << "\n";
return 0;
}
| 1 |
#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 ^ 48), ch = getchar();
x *= f;
return;
}
template <typename T>
void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
return;
}
inline long long mul(long long a, long long b) { return a * b % 998244353; }
inline long long add(long long a, long long b) { return (a + b) % 998244353; }
const int MAXN = 500010;
int n, m;
char s[MAXN];
int a[MAXN];
struct node {
int l, r;
long long val[4];
} f[MAXN * 4];
inline void pushup(int p) {
int na = (f[(p << 1)].r - f[(p << 1)].l + 1) == 1 ? 0 : 1;
int nb = (f[(p << 1 | 1)].r - f[(p << 1 | 1)].l + 1) == 1 ? 0 : 2;
f[p].val[0] = mul(f[(p << 1)].val[na], f[(p << 1 | 1)].val[nb]);
f[p].val[1] = mul(f[(p << 1)].val[na], f[(p << 1 | 1)].val[3]);
f[p].val[2] = mul(f[(p << 1)].val[3], f[(p << 1 | 1)].val[nb]);
f[p].val[3] = mul(f[(p << 1)].val[3], f[(p << 1 | 1)].val[3]);
int x = a[f[(p << 1)].r], y = a[f[(p << 1 | 1)].l];
if (x == 1) {
int na = (f[(p << 1)].r - f[(p << 1)].l + 1) == 1 ? 2 : 0;
int nb = (f[(p << 1 | 1)].r - f[(p << 1 | 1)].l + 1) == 1 ? 1 : 0;
f[p].val[na + nb] = add(f[p].val[na + nb],
mul(mul(f[(p << 1)].val[0], f[(p << 1 | 1)].val[0]),
19 - (10 * x + y)));
f[p].val[na + 1] = add(f[p].val[na + 1],
mul(mul(f[(p << 1)].val[0], f[(p << 1 | 1)].val[1]),
19 - (10 * x + y)));
f[p].val[2 + nb] = add(f[p].val[2 + nb],
mul(mul(f[(p << 1)].val[2], f[(p << 1 | 1)].val[0]),
19 - (10 * x + y)));
f[p].val[3] =
add(f[p].val[3], mul(mul(f[(p << 1)].val[2], f[(p << 1 | 1)].val[1]),
19 - (10 * x + y)));
}
}
void build(int p, int l, int r) {
f[p].l = l, f[p].r = r;
if (l == r) {
f[p].val[0] = 1, f[p].val[3] = a[l] + 1;
return;
}
int mid = (l + r) >> 1;
build((p << 1), l, mid), build((p << 1 | 1), mid + 1, r);
pushup(p);
}
void modify(int p, int x, int y) {
if (f[p].l == f[p].r) {
f[p].val[3] = y + 1;
return;
}
int mid = (f[p].l + f[p].r) >> 1;
if (x <= mid)
modify((p << 1), x, y);
else
modify((p << 1 | 1), x, y);
pushup(p);
}
int main() {
read(n), read(m);
scanf("%s", s + 1);
for (int i = 1; i <= n; ++i) a[i] = s[i] - '0';
build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int x, y;
read(x), read(y);
a[x] = y;
modify(1, x, y);
write(f[1].val[3]), putchar('\n');
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
long long l, r, k, b[20], getans[20], tot, ans;
using namespace std;
int search(long long xx, long long p, long long a) {
int j;
if (p < k && a < ans) {
for (j = 1; j <= k; j++) getans[j] = b[j];
ans = a;
}
if (p == 0 || xx > r) return 1;
search(xx + 1, p, a);
tot++;
b[tot] = xx;
search(xx + 1, p - 1, a ^ xx);
b[tot] = 0;
tot--;
}
int main() {
long long x, len, y, z, i;
cin >> l >> r >> k;
if ((r - l + 1) <= 5) {
ans = l;
tot = 0;
for (i = 1; i <= k; i++) b[i] = 0;
search(l, k, 0);
tot = 0;
for (i = 1; i <= k; i++)
if (getans[i] > 0) tot++;
if (tot > 0) {
cout << ans << endl;
cout << tot << endl;
for (i = 1; i <= tot - 1; i++) cout << getans[i] << " ";
cout << getans[tot];
} else {
cout << ans << endl;
cout << "1" << endl;
cout << l << endl;
}
} else {
if (k == 1) {
cout << l << endl << "1" << endl << l << endl;
} else if (k == 2) {
cout << "1" << endl << "2" << endl;
if (l % 2 == 1) l++;
cout << l << " " << l + 1 << endl;
} else if (k >= 4) {
cout << "0" << endl << "4" << endl;
if (l % 2 == 1) l++;
cout << l << " " << l + 1 << " " << l + 2 << " " << l + 3 << endl;
} else {
x = l;
len = 0;
while (x > 0) {
len++;
x = x / 2;
}
x = ((long long)1 << (len)) + ((long long)1 << (len - 1));
if (x <= r) {
cout << "0" << endl << "3" << endl;
y = x - 1;
z = ((long long)1 << len) - 1;
cout << z << " " << y << " " << x << endl;
} else {
cout << "1" << endl << "2" << endl;
if (l % 2 == 1) l++;
cout << l << " " << l + 1 << endl;
}
}
}
i = 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
int main() {
ios::sync_with_stdio(false);
long long n;
cin >> n;
vector<long long> a(n), b(n);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
vector<long long> cur(n);
for (long long i = 0; i < n; i++) {
cur[i] = a[i] * (i + 1) * (n - i);
}
sort(cur.begin(), cur.end());
sort(b.rbegin(), b.rend());
long long res = 0;
for (long long i = 0; i < n; i++) {
res = (res + (b[i] * (cur[i] % MOD))) % MOD;
}
cout << res % MOD << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int a[maxn];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<pair<int, int> > P;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
if (gcd(a[i], a[i + 1]) != 1) P.push_back(make_pair(1, i));
}
cout << P.size() << endl;
int j = 0;
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
if (j < P.size() && P[j].second == i) {
cout << P[j].first << " ";
j++;
}
}
cout << endl;
}
| 1 |
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
//#include <utility>
#include <set>
#include <iostream>
//#include <memory>
#include <string>
#include <vector>
#include <algorithm>
//#include <functional>
#include <sstream>
//#include <deque>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
//#include <cctype>
#include <cstring>
//#include <ctime>
#include <iterator>
#include <bitset>
//#include <numeric>
//#include <list>
//#include <iomanip>
#if __cplusplus >= 201103L
#include <array>
#include <tuple>
#include <initializer_list>
#include <unordered_set>
#include <unordered_map>
#include <forward_list>
#define cauto const auto&
#else
#endif
using namespace std;
namespace{
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;
#define VV(T) vector<vector< T > >
template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
v.assign(a, vector<T>(b, t));
}
template <class F, class T>
void convert(const F &f, T &t){
stringstream ss;
ss << f;
ss >> t;
}
#define reep(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) reep((i),0,(n))
#define ALL(v) (v).begin(),(v).end()
#define PB push_back
#define F first
#define S second
#define mkp make_pair
#define RALL(v) (v).rbegin(),(v).rend()
#define MOD 1000000007LL
#define EPS 1e-8
static const int INF=1<<24;
void mainmain(){
int n;
while(cin>>n,n){
ll ans=0;
rep(i,n){
int a,b,c,d;
cin>>a>>b>>c>>d;
int M=a+b+c;
if(160<M||d>25) continue;
if(140<M||d>20) ans+=1600;
else if(120<M||d>15) ans+=1400;
else if(100<M||d>10) ans+=1200;
else if(80<M||d>5) ans+=1000;
else if(60<M||d>2) ans+=800;
else ans+=600;
}
cout<<ans<<endl;
}
}
}
int main() try{
mainmain();
}
catch(...){
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a1, a2, n, x = 0;
cin >> a1 >> a2 >> n;
long long int c = n % 6;
if (c == 1) x = a1 % 1000000007;
if (c == 2) x = (a2) % 1000000007;
if (c == 3) x = (a2 - a1) % 1000000007;
if (c == 4) x = (-1 * a1) % 1000000007;
if (c == 5) x = (-1 * a2) % 1000000007;
if (c == 0) x = (a1 - a2) % 1000000007;
if (x < 0) {
x = 1000000007 + (x % 1000000007);
}
cout << x;
return 0;
}
| 2 |
#include <iostream>
#include <math.h>
using namespace std;
int insSort(int *a, int n, int g) {
int j, key, cnt = 0;
for (int i = g; i < n; i++) {
key = a[i];
j = i - g;
while(( j >= 0) && (a[j] > key)) {
a[j+g] = a[j];
j = j - g;
cnt++;
}
a[j+g] = key;
}
return cnt;
}
int main(){
int n, m, cnt=0;
cin >> n;
int *a = new int[n];
for (int i = 0; i < n; i++)
cin >> a[i];
for (m = 1; m < n + 2; m++) {
if ((pow( 3 , m ) -1) / 2 > n) {
m = m - 1;
break;
}
}
int *g = new int[m];
for (int i = 0; i < m; i++ ) {
g[i] = (pow(3, m - i) -1) / 2;
cnt += insSort(a, n, g[i]);
}
cout << m << endl;
for (int i = 0; i < m - 1; i++ )
cout << g[i] << ' ';
cout << g[m - 1] << endl;
cout << cnt << endl;
for (int i = 0; i < n; i++)
cout << a[i] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool check(const string& s) {
int chars[26] = {};
for (char ch : s) {
chars[ch - 'a']++;
if (chars[ch - 'a'] > 1) return false;
}
return true;
}
bool has_similar(const string& s1, const string& s2) {
int ch1[26] = {};
int ch2[26] = {};
for (char ch : s1) {
ch1[ch - 'a']++;
}
for (char ch : s2) {
ch2[ch - 'a']++;
}
for (int i = 0; i < 26; ++i)
if (ch1[i] == 1 && ch1[i] == ch2[i]) return true;
return false;
}
string can_append(const string& s2, const string& s1) {
if (s2.find(s1[0]) != string::npos) {
int ind = s2.find(s1[0]);
int k = 0;
for (int i = ind; i < (int)s2.size(); ++k, ++i) {
if (s2[i] != s1[k]) return "";
}
return s2 + s1.substr(k);
}
return "";
}
string can_merge(const string& s1, const string& s2) {
if (s1.find(s2) != string::npos) {
return s1;
} else if (s2.find(s1) != string::npos)
return s2;
else {
string ans;
ans = can_append(s1, s2);
if (ans != "" && check(ans)) return ans;
ans = can_append(s2, s1);
if (check(ans)) return ans;
}
return "";
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<string> a;
for (int i = 0; i < n; ++i) {
string t;
cin >> t;
if (!check(t)) {
cout << "NO\n";
return 0;
}
a.push_back(t);
}
set<string> parts;
parts.insert(a[0]);
for (int i = 1; i < n; ++i) {
bool has_sim = true;
string next = a[i];
vector<string> where;
for (auto s : parts) {
if (has_similar(next, s)) {
has_sim = false;
string m = can_merge(next, s);
if (m == "") {
cout << "NO\n";
return 0;
}
where.push_back(s);
next = m;
}
}
if (!where.empty()) {
for (auto s : where) parts.erase(s);
parts.insert(next);
}
if (has_sim) parts.insert(a[i]);
}
for (auto s : parts) cout << s;
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (true) {
if (a > b) swap(a, b);
if (a == 0) return b;
long long p = b % a, q = a;
a = p;
b = q;
}
}
long long powerMod(long long x, long long y) {
long long res = 1;
x %= 998244353;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353;
y = y >> 1;
x = (x * x) % 998244353;
}
return res % 998244353;
}
vector<int> tree;
void upd(int idx, int v) {
for (; idx < tree.size(); idx += (idx & (-idx))) {
tree[idx] += v;
}
}
void updr(int start, int end, int v) {
upd(start, v);
upd(end + 1, -v);
}
int query(int idx) {
int sum = 0;
for (; idx > 0; idx -= (idx & (-idx))) {
sum += tree[idx];
}
return sum;
}
void solve() {
int n, i, j, k, l, p;
string s, t;
cin >> n >> s;
t = s;
reverse(t.begin(), t.end());
set<int> st[26];
for (i = 0; i < n; i++) {
st[t[i] - 97].insert(i + 1);
}
vector<int> a(n);
for (i = 0; s[i]; i++) {
if (st[s[i] - 97].size()) {
a[i] = *st[s[i] - 97].begin();
st[s[i] - 97].erase(a[i]);
}
}
tree.resize(n + 1, 0);
long long ans = 0LL;
for (i = n - 1; i >= 0; i--) {
ans += query(a[i]);
upd(a[i], 1);
}
cout << ans << "\n";
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
solve();
tree.clear();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[400005];
int num[400005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int i;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
int g = 0, b = 0, s = 0;
map<int, int> m;
int cnt = 0;
num[cnt++] = a[0];
m[a[0]]++;
int len = n / 2;
if (len >= 3) {
for (i = 1; i < len; i++) {
if (a[i] != a[i - 1]) num[cnt++] = a[i];
m[a[i]]++;
}
while (i < n && a[i] == a[i - 1]) m[a[i]]++, i++;
g = m[num[0]];
for (i = 1; i < cnt && s <= g; i++) s += m[num[i]];
for (i; i < cnt; i++) b += m[num[i]];
int x = cnt;
while (g + s + b > len) b -= m[num[--x]];
if (g > 0 && s > 0 && g < b)
printf("%d %d %d\n", g, s, b);
else
printf("0 0 0\n");
} else
printf("0 0 0\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
long a[220000];
long b[220000];
int main() {
int m, n, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
b[i] += b[i - 1];
}
int ans = 0;
for (int i = 0; i <= n; i++) {
if (a[i] > k) break;
ans = max(ans, int(i + (lower_bound(b, b + m + 1, k - a[i] + 1) - b)) - 1);
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, time, a[100001];
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
time = min(1000000 - a[1], a[n] - 1);
for (int i = 1; i <= n; i++)
if (i != 1)
time = min(time, min(max(a[i - 1] - 1, 1000000 - a[i]),
max(a[i] - 1, 1000000 - a[i + 1])));
cout << time;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int points[100000];
int distances[100000];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> points[i];
sort(points, points + n);
for (int i = 1; i < n; ++i) distances[i - 1] = points[i] - points[i - 1];
int all_gcd = distances[0];
for (int i = 1; i < n - 1; ++i) all_gcd = gcd(all_gcd, distances[i]);
int res = 0;
for (int i = 0; i < n - 1; ++i) {
res += (distances[i] / all_gcd - 1);
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p, q, r;
cin >> n >> p >> q >> r;
long long int ar[n + 1];
int i;
for (i = 0; i < n; i++) cin >> ar[i];
long long int ans = LONG_LONG_MIN;
long long int prev_max = LONG_LONG_MIN;
long long int first_max = LONG_LONG_MIN;
for (i = 0; i < n; i++) {
ans = max(ans, (p + q + r) * (ar[i]));
prev_max = max(prev_max, (p + q) * ar[i]);
first_max = max(first_max, p * ar[i]);
prev_max = max(prev_max, first_max + q * ar[i]);
ans = max(ans, prev_max + r * ar[i]);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int x, i, a, b;
scanf("%d", &x);
int n[x];
for (i = 0; i < x; i++) {
scanf("%d", &n[i]);
if (n[i] == 0)
a = i;
else
b = i;
}
printf("%d\n", a < b ? a + 1 : b + 1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int t, a1, b1, a2, b2;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> a1 >> b1;
cin >> a2 >> b2;
long int al1, l1, al2, l2;
if (a1 > b1) {
al1 = b1;
l1 = a1;
} else {
al1 = a1;
l1 = b1;
}
if (a2 > b2) {
al2 = b2;
l2 = a2;
} else {
al2 = a2;
l2 = b2;
}
if (l1 == l2) {
if ((al1 + al2) == l1) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int color(char c) {
switch (c) {
case 'R':
return 0;
case 'G':
return 1;
case 'B':
return 2;
case 'Y':
return 3;
case 'W':
return 4;
}
}
int count_bits(int x) {
int cnt = 0;
for (; x; x >>= 1)
if (x & 1) ++cnt;
return cnt;
}
int f[5][5];
int solve(int x, int y) {
vector<pair<int, int> > c;
for (int i = 0; i < 5; ++i)
for (int j = 0; j < 5; ++j)
if (f[i][j]) {
int a = ((x >> i) & 1) ? i : -1;
int b = ((y >> j) & 1) ? j : -1;
c.push_back(make_pair(a, b));
}
sort(c.begin(), c.end());
if (unique(c.begin(), c.end()) != c.end()) return 0x3f3f3f3f;
return count_bits(x) + count_bits(y);
}
int main() {
char a[12];
int m;
cin >> m;
while (m--) {
scanf("%s", a);
int c = color(a[0]);
int n = a[1] - '0' - 1;
f[c][n]++;
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < (1 << 5); ++i)
for (int j = 0; j < (1 << 5); ++j) ans = min(ans, solve(i, j));
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.0);
int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int N, M;
char v[260][260];
bool visited[260][260];
bool con[260][260], cont[260][260];
void dfs(int j, int k) {
visited[j][k] = true;
con[j][k] = true;
for (int d = 0; d < (int)(8); ++d) {
int y = j + dy[d], x = k + dx[d];
if (y < 0 || x < 0 || y >= M || x >= N) continue;
if (visited[y][x] || v[y][x] == '0') continue;
dfs(y, x);
}
}
bool is_square1() {
memcpy(cont, con, sizeof(cont));
int x0 = -1, x1 = -1, y0 = -1;
for (int y = 0; y < (int)(M); ++y) {
for (int x = 0; x < (int)(N); ++x) {
if (cont[y][x]) {
if (x0 == -1) {
x0 = x1 = x;
y0 = y;
} else if (y0 == y && x1 == x - 1) {
x1 = x;
}
}
}
}
int w = x1 - x0;
if (w == 0) return false;
if (y0 + w >= M) return false;
for (int x = (x0); x <= (int)(x0 + w); ++x)
if (!(cont[y0][x] && cont[y0 + w][x])) return false;
for (int y = (y0); y <= (int)(y0 + w); ++y)
if (!(cont[y][x0] && cont[y][x1])) return false;
for (int x = (x0); x <= (int)(x0 + w); ++x) {
cont[y0][x] = false;
cont[y0 + w][x] = false;
}
for (int y = (y0); y <= (int)(y0 + w); ++y) {
cont[y][x0] = false;
cont[y][x1] = false;
}
for (int y = 0; y < (int)(M); ++y)
for (int x = 0; x < (int)(N); ++x)
if (cont[y][x]) return false;
return true;
}
bool is_square2() {
memcpy(cont, con, sizeof(cont));
int x0 = -1, x1 = -1, y0 = -1;
for (int y = 0; y < (int)(M); ++y) {
for (int x = 0; x < (int)(N); ++x) {
if (cont[y][x]) {
if (x0 == -1) {
x0 = x1 = x;
y0 = y;
} else if (x < x0) {
x0 = x;
y0 = y;
} else if (x > x1) {
x1 = x;
}
}
}
}
int w = (x1 - x0) / 2;
if (w == 0) return false;
if (y0 + w >= M) return false;
for (int d = (0); d <= (int)(w); ++d)
if (!(cont[y0 + d][x0 + d] && cont[y0 - d][x0 + d] &&
cont[y0 + d][x1 - d] && cont[y0 - d][x1 - d]))
return false;
for (int d = (0); d <= (int)(w); ++d) {
cont[y0 + d][x0 + d] = false;
cont[y0 - d][x0 + d] = false;
cont[y0 + d][x1 - d] = false;
cont[y0 - d][x1 - d] = false;
}
for (int y = 0; y < (int)(M); ++y)
for (int x = 0; x < (int)(N); ++x)
if (cont[y][x]) return false;
return true;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &M, &N);
for (int j = 0; j < (int)(M); ++j) scanf("%s", v[j]);
memset((visited), (false), sizeof(visited));
int res = 0;
for (int j = 0; j < (int)(M); ++j) {
for (int k = 0; k < (int)(N); ++k) {
if (visited[j][k] || v[j][k] == '0') continue;
memset((con), (false), sizeof(con));
dfs(j, k);
if (is_square1() || is_square2()) res++;
}
}
printf("%d\n", res);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn3 = 1e3 + 10;
const long long int Maxn4 = 1e4 + 10;
const long long int Maxn5 = 1e5 + 10;
const long long int Maxn6 = 1e6 + 10;
const long long int Maxn7 = 1e7 + 10;
const long long int Maxn8 = 1e8 + 10;
const long long int Maxn9 = 1e9 + 10;
const long long int Maxn18 = 1e18 + 10;
const long long int Mod1 = 1e7 + 7;
const long long int Mod2 = 1e9 + 7;
const long long int LLMax = LLONG_MAX;
const long long int LLMin = LLONG_MIN;
const long long int INTMax = INT_MAX;
const long long int INTMin = INT_MIN;
long long int mn = LLMax, mx = LLMin;
long long int a[1000], b[1000];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, m;
cin >> n >> m;
if (m < n) return cout << 0, 0;
long long int l;
for (long long int i = 1; i <= m; i++) cin >> l, a[l]++;
for (long long int i = 1; i <= 100; i++) b[i] = a[i];
sort(b + 1, b + 100 + 1);
long long int ans = 0;
for (long long int i = 1; i <= 100; i++) {
long long int p = 0;
for (long long int j = 100; j >= 100 - n + 1; j--)
if (b[j] / i) p += b[j] / i;
if (p >= n) ((ans) = max((ans), (i)));
}
return cout << ans, 0;
}
| 2 |
#include <algorithm>
#include <map>
#include <iostream>
#include <cstdio>
using namespace std;
using ll = long long int;
const int DIGIT = 14 + 1;
const int MAXS = DIGIT * 9 + 1;
map<ll, ll> dp[DIGIT][MAXS][3];
string str;
ll N, sum, prod;
ll solve(int d, int s, int f, ll p) {
if(d == N) {
if(s < sum) return 1;
else if(s == sum and p < prod) return 1;
else if(s == sum and p == prod) {
if(f == 1) return 1;
else return 0;
}
else return 0;
}
if(dp[d][s][f].count(p)) return dp[d][s][f][p];
int num = str[d] - '0';
ll res = 0;
for(int x=0; x<=9; x++) {
int ns = s + x;
int nf = f;
if(nf == 0 and x < num) nf = 1;
if(nf == 0 and x > num) nf = 2;
ll np = p * (x + 1);
res += solve(d+1, ns, nf, np);
}
return dp[d][s][f][p] = res;
}
int main() {
cin >> str;
N = str.length(); prod = 1;
for(int i=0; i<N; i++) {
int c = str[i] - '0';
sum += c;
prod *= (c + 1);
}
cout << solve(0, 0, 0, 1) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[101], ans = 1000000001;
void in() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
}
void make() {
if (m <= k)
printf("0\n");
else {
sort(a, a + n, greater<int>());
for (int i = k - 1; i >= 0; i--) {
if (k - i > n) continue;
int remaining = m - i, s = 0;
for (int j = 0; j < k - i; j++) {
s += a[j];
if (s >= remaining) {
cout << j + 1 << endl;
return;
}
}
if (s < remaining) {
for (int j = k - i; j < n; j++) {
s += a[j];
s--;
if (s >= remaining) {
cout << j + 1 << endl;
return;
}
}
}
}
printf("-1\n");
}
}
int main() {
in();
make();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool can(long long x, long long y, long long m, long long n) {
if (m == 0 && n == 0) return x == 0 && y == 0;
return abs(x * m + y * n) % (m * m + n * n) == 0 &&
abs(x * n - y * m) % (m * m + n * n) == 0;
}
int main() {
int A[2], B[2], C[2];
while (cin >> A[0] >> A[1] >> B[0] >> B[1] >> C[0] >> C[1]) {
bool ok = 0;
ok |= can(B[0] - A[0], B[1] - A[1], C[0], C[1]);
ok |= can(B[0] + A[0], B[1] + A[1], C[0], C[1]);
ok |= can(B[0] - A[1], B[1] + A[0], C[0], C[1]);
ok |= can(B[0] + A[1], B[1] - A[0], C[0], C[1]);
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int oo = 2139063143;
const int N = 1210000;
const int P = 1000000007;
using namespace std;
inline void sc(int &x) {
x = 0;
static int p;
p = 1;
static char c;
c = getchar();
while (!isdigit(c)) {
if (c == '-') p = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c - 48);
c = getchar();
}
x *= p;
}
inline void print(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
inline void pr(long long x) { print(x), putchar('\n'); }
struct EDGE {
int v, nx;
} lb[N];
int tote = 1, top[N];
void addedge(int u, int v) { lb[++tote] = (EDGE){v, top[u]}, top[u] = tote; }
int dfn[N], las[N];
void dfs(int u) {
dfn[u] = ++dfn[0];
for (int kb = top[u]; kb; kb = lb[kb].nx) dfs(lb[kb].v);
las[u] = dfn[0];
}
int bit[N];
void add(int x, int d) {
for (; x <= dfn[0]; x += x & -x) bit[x] += d;
}
int sum(int x) {
int ans = 0;
for (; x; x -= x & -x) ans += bit[x];
return ans;
}
struct ACAM {
int fa, son[27];
} ac[N];
int totp = 1;
int pos[N];
void ins(char *s, int n, int id) {
int p = 1;
for (int i = 1; i <= n; i++) {
int &v = ac[p].son[s[i] - 'a' + 1];
if (!v) v = ++totp;
p = v;
}
pos[id] = p;
}
queue<int> q;
void build() {
for (int i = 1; i <= 26; i++) ac[0].son[i] = 1;
q.push(1);
while (q.size()) {
int u = q.front(), f = ac[u].fa;
q.pop();
for (int c = 1; c <= 26; c++) {
int &v = ac[u].son[c], g = ac[f].son[c];
if (v)
ac[v].fa = g, q.push(v);
else
v = g;
}
}
}
bool vis[N];
char s[N];
int main() {
int m, n;
sc(m), sc(n);
for (int i = 1; i <= n; i++)
scanf("%s", s + 1), ins(s, strlen(s + 1), i), vis[i] = 1;
build();
for (int i = 1; i <= totp; i++) addedge(ac[i].fa, i);
dfs(1);
for (int i = 1; i <= n; i++) add(dfn[pos[i]], 1), add(las[pos[i]] + 1, -1);
while (m--) {
scanf("%s", s);
int len = strlen(s);
if (s[0] == '?') {
int cur = 1;
long long ans = 0;
for (int i = 1; i < len; i++) {
cur = ac[cur].son[s[i] - 'a' + 1];
ans += sum(dfn[cur]);
}
pr(ans);
} else {
int id = 0;
for (int i = 1; i < len; i++) id = id * 10 + s[i] - '0';
if ((s[0] == '+') == vis[id]) continue;
add(dfn[pos[id]], s[0] == '+' ? 1 : -1),
add(las[pos[id]] + 1, s[0] == '+' ? -1 : 1);
vis[id] = s[0] == '+';
}
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 3e5+5;
const int mod = 998244353;
int n,id[257];
int a[3][N],type[N],cnt[4];
char s[N];
int main(){
id['R']=0;id['G']=1;id['B']=2;
scanf("%d%s",&n,s+1);
for(int i=1;i<=n*3;++i){
int x=id[s[i]];
a[x][++a[x][0]]=i;
}
for(int i=1;i<=n;++i){
int x=0,y=1,z=2;
if(a[y][i]>a[x][i])swap(x,y);
if(a[z][i]>a[x][i])swap(x,z);
if(a[z][i]>a[y][i])swap(y,z);
type[a[z][i]]=0;
type[a[y][i]]=1;
type[a[x][i]]=2;
}
ll ans=1;
cnt[0]=n;
for(int i=1;i<=3*n;++i){
int x=type[i];
ans=ans*cnt[x]%mod;
cnt[x]--;
cnt[x+1]++;
}
printf("%lld\n",ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string p, h;
cin >> p >> h;
sort(p.begin(), p.end());
bool ok = false;
for (int i = 0; i < h.size(); i++) {
string chk = h.substr(i, p.size());
sort(chk.begin(), chk.end());
if (p == chk) {
ok = true;
break;
}
}
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define N 1200
const LL mod=1000000007;
LL n,rt,rt1,rt2,q[N],tot,len,head[N],f[N][N][2],fa[N],dep[N];
bool vis[N];
struct edge{LL v,nxt;}e[N<<1];
void add(LL x,LL y){
e[++tot].v=y; e[tot].nxt=head[x]; head[x]=tot;
}
LL bfs(LL s){
memset(vis,0,sizeof vis);
LL tt=0,ww=1; q[1]=s; vis[s]=1;
while (tt<ww){
LL u=q[++tt];
for (LL i=head[u],v;i;i=e[i].nxt)
if (!vis[v=e[i].v]){vis[v]=1; q[++ww]=v;}
}
return q[n];
}
void dfs(LL u){
for (LL i=head[u],v;i;i=e[i].nxt)
if ((v=e[i].v)!=fa[u]){fa[v]=u; dfs(v);}
}
void dp(LL u){
for (LL i=0;i<=len-dep[u];++i) f[u][i][0]=f[u][i][1]=f[u][i+1][1]=1;
for (LL i=head[u],v;i;i=e[i].nxt)
if ((v=e[i].v)!=fa[u]){
dep[v]=dep[u]+1; fa[v]=u; dp(v);
for (LL j=0;j<=len;++j){
f[u][j][0]=f[u][j][0]*(f[v][j][0]+(j?f[v][j-1][0]:0))%mod;
f[u][j][1]=f[u][j][1]*(f[v][j][1]+(j?f[v][j-1][1]:0))%mod;
}
}
}
int main(){
scanf("%lld",&n);
for (LL i=1;i<n;++i){
LL x,y; scanf("%lld%lld",&x,&y);
add(x,y); add(y,x);
}
LL S=bfs(1); LL T=bfs(S); dfs(S);
len=0; for (LL i=T;i!=S;i=fa[i]) ++len;
if (len&1){
len/=2;
rt1=T; for (int i=1;i<=len;++i) rt1=fa[rt1]; rt2=fa[rt1];
memset(fa,0,sizeof fa);
fa[rt1]=rt2; fa[rt2]=rt1;
dp(rt1); dp(rt2);
LL ans=0;
#define f1 f[rt1]
#define f2 f[rt2]
for (LL i=0;i<=len;++i)
ans=(ans+f1[i][0]*(f2[i][1]+f2[i+1][1]-f2[i][0])%mod
+f2[i][0]*(f1[i][1]+f1[i+1][1]-f1[i][0])%mod
-f1[i][0]*f2[i+1][0]%mod-f1[i+1][0]*f2[i][0]%mod+mod*10)%mod;
printf("%lld\n",ans);
}
else{
len/=2;
rt=T; for (int i=1;i<=len;++i) rt=fa[rt];
memset(fa,0,sizeof fa);
dp(rt);
LL ans=0;
for (LL i=0;i<=len;++i) ans=(ans+f[rt][i][0])%mod;
printf("%lld\n",ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, l[200], r[300], v[300];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> l[i] >> r[i];
}
int t = 0;
for (int i = 1; i <= n; ++i) {
if (l[i] == 0) {
v[i] = t;
int x = r[i];
while (x) {
v[x] = t;
x = r[x];
}
++t;
}
}
for (int i = 1; i <= n && t > 1; ++i) {
if (r[i] == 0) {
for (int j = 1; j <= n; ++j) {
if (i == j) continue;
if (l[j] == 0 && v[i] != v[j]) {
l[j] = i;
r[i] = j;
int x = v[i];
for (int a = 1; a <= n; ++a)
if (v[a] == x) v[a] = v[j];
break;
}
}
--t;
}
}
for (int i = 1; i <= n; ++i) cout << l[i] << " " << r[i] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long m = 1000000007;
void dfs(long long x, vector<long long> v1[], bool vis[]) {
vis[x] = true;
for (long long i = 0; i < v1[x].size(); i++) {
if (vis[v1[x][i]] == false) {
vis[v1[x][i]] = true;
dfs(v1[x][i], v1, vis);
}
}
}
long long power(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
long long cnt = 0;
void dfs(long long x, vector<long long> v1[], bool vis[], long long v) {
cnt++;
vis[x] = true;
for (long long i = 0; i < v1[x].size(); i++) {
if (vis[v1[x][i]] == false) {
vis[v1[x][i]] = true;
dfs(v1[x][i], v1, vis, 1);
}
}
}
signed main() {
long long n, k;
cin >> n >> k;
vector<long long> v[n + 1];
vector<long long> v1[n + 1];
vector<long long> v2;
bool vis[n + 1];
memset(vis, false, sizeof(vis));
for (long long i = 0; i < n - 1; i++) {
long long u, vv, x;
cin >> u >> vv >> x;
v[u].push_back(vv);
v[vv].push_back(u);
if (x == 0) {
v1[u].push_back(vv);
v1[vv].push_back(u);
if (vis[u] == false) {
v2.push_back(u);
vis[u] = true;
}
if (vis[vv] == false) {
v2.push_back(vv);
vis[vv] = true;
}
}
}
long long con = 0;
memset(vis, false, sizeof(vis));
for (long long i = 0; i < v2.size(); i++) {
if (vis[v2[i]] == false) {
dfs(v2[i], v1, vis);
con++;
}
}
long long c[con + 1];
memset(c, 0, sizeof(c));
con = 0;
memset(vis, false, sizeof(vis));
for (long long i = 0; i < v2.size(); i++) {
if (vis[v2[i]] == false) {
dfs(v2[i], v1, vis, 1);
con++;
c[con] = cnt;
cnt = 0;
}
}
long long pro;
pro = power(n, k);
long long ans = 0;
for (long long i = 1; i <= con; i++) {
pro -= power(c[i], k);
pro += m;
pro %= m;
pro += c[i];
}
pro -= n;
cout << pro << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long i, n, k, w, z;
string s;
vector<long long> v;
int main() {
cin >> n;
cin >> s;
s = s + 'p';
for (i = 0; i <= n; i++) {
if (s[i] == '1')
k++;
else {
v.push_back(k);
k = 0;
}
}
for (i = 0; i < v.size(); i++) {
cout << v[i];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e6 + 100;
long long int const LINF = numeric_limits<long long int>::max();
int const INF = numeric_limits<int>::max();
int const BN = 31;
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int pow_mod(long long int a, long long int e, long long int m) {
long long int res = 1;
while (e) {
if (e & 1) res = res * a % m;
a = a * a % m;
e >>= 1;
}
return res;
}
long long int inv_mod(long long int b, long long int m) {
b %= m;
long long int x = 0, y = 1, r, q, a = m;
while (b) {
q = a / b;
r = a % b;
a = b;
b = r;
r = x;
x = y;
y = r - q * y;
}
x += m;
return x % m;
}
int row_gcd(string str[], int n) {
int ret = 0;
for (int i = 0; i < n; i++) {
char ch = 'a';
int cnt = 0;
for (int j = 0; j < n; j++) {
if (ch != str[i][j]) {
ret = gcd(ret, cnt);
cnt = 1;
} else
cnt++;
ch = str[i][j];
}
ret = gcd(ret, cnt);
}
return ret;
}
int col_gcd(string str[], int n) {
int ret = 0;
for (int j = 0; j < n; j++) {
char ch = 'a';
int cnt = 0;
for (int i = 0; i < n; i++) {
if (ch != str[i][j]) {
ret = gcd(ret, cnt);
cnt = 1;
} else
cnt++;
ch = str[i][j];
}
ret = gcd(ret, cnt);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n;
string mat[n];
m = n / 4;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
mat[i] = "";
for (int j = 0; j < m; j++) {
if (str[j] <= '9') {
mat[i] += bitset<4>(str[j] - '0').to_string();
} else {
mat[i] += bitset<4>(str[j] - 'A' + 10).to_string();
}
}
}
int g1 = row_gcd(mat, n);
int g2 = col_gcd(mat, n);
int ans = gcd(n, gcd(g1, g2));
cout << ans << endl;
}
| 4 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(), (a).end()
#define pb emplace_back
#define INF (1e9+1)
int main(){
int n,m;
cin>>n>>m;
vector<int> a(n), b(n), c(n);
rep(i,n){
cin>>a[i]>>b[i]>>c[i];
}
static int dp[10001][101];
rep(i,10001)rep(j,101)dp[i][j] = -INF;
dp[0][0] = 0;
rep(i,n){
for(int j = 10000;j>=0;j--){
for(int k = 100;k>=0;k--){
if(dp[j][k]<0)continue;
int A = j, B = dp[j][k], C = k;
if( A+a[i]<=10000 && C+c[i]<=100 )dp[A+a[i]][C+c[i]] = max(dp[A+a[i]][C+c[i]], B + b[i]);
if( A+b[i]>=B+a[i] && A+b[i]<=10000 && C+c[i]<=100 ){
dp[A+b[i]][C+c[i]] = max(dp[A+b[i]][C+c[i]], B + a[i]);
}
if( A+b[i]<=B+a[i] && B+b[i]<=10000 && C+c[i]<=100){
dp[B+a[i]][C+c[i]] = max(dp[B+a[i]][C+c[i]], A + b[i]);
}
}
}
}
int ans = -INF;
rep(i,10001)rep(j,m+1){
assert(i>=dp[i][j]);
ans = max(ans,dp[i][j]);
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 2e5;
const long long inf = 1e18;
template <typename... T>
void read(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void write(T&&... args) {
((cout << args << " "), ...);
}
template <typename... T>
void writeline(T&&... args) {
((cout << args << " "), ...);
cout << "\n";
}
long long add(long long a, long long b) {
long long res = (a + b) % mod;
return (res < 0) ? res + mod : res;
}
long long mul(long long a, long long b) {
long long res = (a * 1LL * b) % mod;
return (res < 0) ? res + mod : res;
}
string binary(long long x) {
string res = "";
for (long long i = 0; i < 32; i++) res += (1 << i & x) ? '1' : '0';
return res;
}
long long in(long long x, long long y, long long z) {
if (y > z) swap(y, z);
return (x >= y && x <= z);
}
struct customCompare {
bool operator()(long long x, long long y) { return x > y; }
};
long long sky[105][105][11];
void fun() {
for (long long i = 1; i < 105; i++) {
for (long long j = 1; j < 105; j++) {
for (long long k = 0; k < 11; k++) {
sky[i][j][k] +=
sky[i - 1][j][k] + sky[i][j - 1][k] - sky[i - 1][j - 1][k];
}
}
}
}
void solve() {
long long n, q, c;
read(n, q, c);
for (long long i = 0; i < n; i++) {
long long x, y, s;
read(x, y, s);
sky[x][y][s]++;
}
fun();
long long ans;
for (long long i = 0; i < q; i++) {
long long t, x1, y1, x2, y2;
read(t, x1, y1, x2, y2);
long long ans = 0;
long long temp[c + 1];
for (long long j = 0; j < c + 1; j++) {
temp[j] = sky[x2][y2][j] - sky[x1 - 1][y2][j] - sky[x2][y1 - 1][j] +
sky[x1 - 1][y1 - 1][j];
}
for (long long j = 0; j < c + 1; j++) {
ans += temp[j] * ((j + t) % (c + 1));
}
writeline(ans);
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, all[100008];
int c;
int main() {
int ans = 0;
scanf("%d%d", &n, &c);
for (int i = 0; i < n; i++) scanf("%d", &all[i]);
for (int i = 0; i < n - 1; i++) {
ans = max(ans, all[i] - all[i + 1] - c);
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAX = 1e6 + 100;
const int eps = 1e-6;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
bool prime(int n) {
if (n < 2) return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
long long power(long long b, long long p) {
if (p == 0) return 1;
long long sq = power(b, p / 2);
sq *= sq;
if (p & 1) sq *= b;
return sq;
}
long long ncr(long long n, long long r) {
long long ans = 1;
if (n - r < r) r = n - r;
for (long long i = 0; i < r; i++) {
ans *= n - i;
ans /= i + 1;
}
return ans;
}
int dx[] = {0, 0, -1, 1, -1, 1, -1, 1};
int dy[] = {1, -1, 0, 0, 1, 1, -1, -1};
int main() {
ios_base::sync_with_stdio(NULL), cout.tie(NULL), cin.tie(NULL);
long long n, a, b, x;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
cin >> x;
long long ans = (x * a) % b;
cout << ans / a << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int b = 0, c = 0, n, k;
string s;
cin >> n >> k;
cin >> s;
for (long long int i = 0; i < n; i++) {
if (s[i] == '.') {
b = max(b, c);
c = 0;
if (b >= k) {
cout << "NO\n";
return 0;
}
} else {
c++;
}
}
cout << "YES\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int tt = 1, ttt = 0;
while (tt--) {
int x, y, z, sum = 0;
scanf("%d", &n);
string str, str2 = "1";
bool isZero = false;
for (int a = 0; a < n; a++) {
cin >> str;
if (str == "0" || isZero) {
isZero = true;
continue;
}
if (str[0] != '1') {
str2 = str;
} else {
bool flag = false;
for (int a = 1; a < str.size(); a++) {
if (str[a] != '0') {
flag = true;
break;
}
}
if (flag) {
str2 = str;
} else {
sum += str.size() - 1;
}
}
}
if (isZero) {
printf("0\n");
} else {
for (int a = 0; a < sum; a++) {
str2 += "0";
}
cout << str2 << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct comp {
bool operator()(pair<int, long long> &a, pair<int, long long> &b) {
return a.second > b.second;
}
};
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, pair<int, int>>> adj[n + 1];
long long dist[n + 1];
int edg[n + 1];
int edge[m + 1];
memset(edge, 0, sizeof(edge));
memset(dist, 0x3f, sizeof(dist));
for (int i = 1; i < n + 1; i++) {
edg[i] = 0;
}
for (int i = 1; i <= m; i++) {
int x, y, z;
cin >> x >> y >> z;
adj[x].push_back(make_pair(y, make_pair(z, i)));
adj[y].push_back(make_pair(x, make_pair(z, i)));
edge[i] = z;
}
int u;
cin >> u;
dist[u] = 0;
priority_queue<pair<int, long long>, vector<pair<int, long long>>, comp> q;
q.push(make_pair(u, 0));
while (!q.empty()) {
int curr_node = q.top().first;
long long curr_dist = q.top().second;
q.pop();
for (int i = 0; i < adj[curr_node].size(); i++) {
int child = adj[curr_node][i].first;
int ed = adj[curr_node][i].second.first;
int edi = adj[curr_node][i].second.second;
if (curr_dist + ed < dist[child]) {
dist[child] = curr_dist + ed;
edg[child] = edi;
q.push(make_pair(child, dist[child]));
} else if (curr_dist + ed == dist[child]) {
int old_e = edge[edg[child]];
if (ed < old_e) {
edg[child] = edi;
}
}
}
}
long long maxx = 0;
for (int i = 1; i < n + 1; i++) {
maxx += edge[edg[i]];
}
cout << maxx << endl;
for (int i = 1; i < n + 1; i++) {
if (edg[i]) cout << edg[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[101];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
int x = a[0];
int y = a[0];
for (int i = 0; i < n; i++) {
if (a[i] < x) x = a[i];
if (a[i] > y) y = a[i];
}
if (y - x > k) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < x; j++) printf("1 ");
for (int j = 0; j < a[i] - x; j++) printf("%d ", j + 1);
printf("\n");
}
return 0;
}
| 2 |
#include <stdio.h>
int main(){
char S[101],T[101];
scanf("%s %s", &S, &T);
printf("%s%s", T,S);
return 0;}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, a, b;
cin >> n >> a >> b;
n = 6 * n;
if (a * b >= n)
cout << (a * b) << "\n" << a << " " << b;
else {
bool flag = 0;
if (a > b) {
swap(a, b);
flag = 1;
}
long long area = 1e18, a1, b1, temp;
for (long long i = a; i * i <= 6 * n; ++i) {
temp = n / i;
if (temp * i < n) temp++;
if (temp >= b) {
if (temp * i < area) {
area = temp * i;
a1 = i;
b1 = temp;
}
}
}
if (flag) swap(a1, b1);
cout << area << "\n" << a1 << " " << b1 << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(2e6 + 100);
int main() {
int n, a[200];
cin >> n;
int ans = -int(1e9);
for (int i = 0; i < n; i++) {
cin >> a[i];
ans = max(ans, a[i]);
}
for (int len = 2; len <= n; len++) {
for (int i = 0; i + len - 1 < n; i++) {
int x = a[i];
for (int j = i + 1; j < i + len; j++) {
x = x ^ a[j];
}
ans = max(x, ans);
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int kkaass = 1;
int n;
vector<pair<int, int> > vec;
char board[4009][4009];
void draw(pair<int, int> a, pair<int, int> b) {
int lim = abs(a.first - b.first);
if (a.second <= b.second) {
for (int i = 0; i < lim; i++) board[a.first + i][1010 + a.second + i] = 'L';
} else {
for (int i = 0; i < lim; i++)
board[a.first + i][1010 + a.second - i - 1] = 'R';
}
}
int main() {
ios_base::sync_with_stdio(false);
while (cin >> n) {
vec.push_back(make_pair(0, 0));
int a = 0, b = 0;
pair<int, int> la = make_pair(0, 0), lb = make_pair(0, 0);
for (int i = 0; i < n; i++) {
int v;
cin >> v;
a += v;
if (i % 2 == 0)
b += v;
else
b -= v;
la.second = a;
lb = make_pair(min(lb.first, b), max(lb.second, b));
vec.push_back(make_pair(a, b));
}
sort(vec.begin(), vec.end());
memset(board, '.', sizeof(board));
for (int i = 0; i < (int)vec.size() - 1; i++) draw(vec[i], vec[i + 1]);
for (int j = lb.second + 1010 - 1; j >= lb.first + 1010 - 1; j--) {
for (int i = 0; i < la.second; i++) {
if (board[i][j] == 'L')
cout << '/';
else if (board[i][j] == 'R')
cout << '\\';
else
cout << ' ';
}
cout << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
const int N = 65600;
complex<long double> oddc[N], evenc[N];
long long odd[N], even[N];
int Odd[N], Even[N];
int R[N], n, C = 1, mo, ans;
void FFT(complex<long double> *a, int f) {
for (int i = (int)(0); i <= (int)(C - 1); i++)
if (i < R[i]) swap(a[i], a[R[i]]);
for (int d = 1; d < C; d <<= 1) {
complex<long double> wn(cos(pi / d), f * sin(pi / d));
for (int i = 0; i < C; i += (d << 1)) {
complex<long double> w(1, 0);
for (int j = i; j < i + d; j++, w *= wn) {
complex<long double> y = a[j + d] * w;
a[j + d] = a[j] - y;
a[j] += y;
}
}
}
}
void dtoc(long long *d, complex<long double> *c) {
for (int i = (int)(0); i <= (int)(C - 1); i++) c[i] = (complex<long double>)0;
for (int i = (int)(0); i <= (int)(n); i++) c[i] = d[i];
FFT(c, 1);
}
void ctod(complex<long double> *c, long long *d) {
FFT(c, -1);
for (int i = (int)(0); i <= (int)(C - 1); i++) c[i] /= C;
for (int i = (int)(0); i <= (int)(n); i++)
d[i] = (long long)(c[i].real() + 0.5);
}
void updans() {
for (int i = 1; i <= n; i += 2) ans = (ans + odd[i]) % mo;
}
void solve(int mx) {
if (mx == 1) {
even[0] = 1;
odd[0] = 0;
odd[1] = 1;
updans();
return;
}
solve(mx / 2);
for (int i = (int)(0); i <= (int)(n); i++) Odd[i] = odd[i];
for (int i = (int)(0); i <= (int)(n); i++) Even[i] = even[i];
dtoc(odd, oddc);
dtoc(even, evenc);
for (int i = (int)(0); i <= (int)(C - 1); i++) {
complex<long double> v1 = (oddc[i] + evenc[i]) * oddc[i];
complex<long double> v2 =
(oddc[i] + evenc[i]) * (evenc[i] - (complex<long double>)1);
if (!(mx & 2))
oddc[i] = v1, evenc[i] = v2;
else
evenc[i] = v1, oddc[i] = v2;
}
ctod(oddc, odd);
ctod(evenc, even);
for (int i = (int)(n + 1); i <= (int)(2 * n); i++) odd[i] = even[i] = 0;
for (int i = (int)(0); i <= (int)(n); i++) {
odd[i] = (odd[i] + Odd[i]) % mo;
even[i] = (even[i] + Even[i]) % mo;
}
if (mx & 1)
for (int i = (int)(n); i >= (int)(1); i--)
odd[i] = (odd[i] + odd[i - 1] + even[i - 1]) % mo;
updans();
}
int main() {
int mx, L = 0;
scanf("%d%d%d", &n, &mx, &mo);
if (mx == 1) return puts("0"), 0;
for (; C <= 2 * n; C <<= 1, L++)
;
for (int i = (int)(1); i <= (int)(C - 1); i++)
R[i] = (R[i >> 1] >> 1) | ((i & 1) << (L - 1));
solve(mx / 2);
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> pos[100010];
int d[100010];
int a[100010];
int n, m;
bool judge(int mid) {
vector<pair<int, int>> course;
for (int i = 1; i <= m; i++) {
vector<int>::iterator it = upper_bound(pos[i].begin(), pos[i].end(), mid);
if (it == pos[i].begin()) return false;
it--;
course.push_back({*it, i});
}
sort(course.begin(), course.end());
int used = 0;
for (auto &c : course) {
if (c.first - 1 - used < a[c.second]) return false;
used += a[c.second] + 1;
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", d + i);
if (d[i] > 0) pos[d[i]].push_back(i);
}
for (int i = 1; i <= m; i++) scanf("%d", a + i);
int l = 1, r = n;
if (!judge(n))
puts("-1");
else {
while (l < r) {
int mid = l + r >> 1;
if (judge(mid))
r = mid;
else
l = mid + 1;
}
printf("%d", l);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long b[1000012], t, n, m, k, ccnt,
pos = 0, sum = 0, minn2 = INT_MAX, sum2, cnt = 0, cnt1 = 0, cnt2 = 0, x, y,
cnt3 = 0, cnt4 = 0, cnt5 = 0, cnt6 = 0, cnt7 = 0, a[1000005], a2[1000005],
x1, y7, x2, y2, x3, y3, bbb;
long long c[1000005], z, d, l2, r2, temcnt, le[1000005], ri[1000005],
ok[2000005], cl, cr, gan, fst, pre[1000005], mxl[1000005], mxr[1000005],
uu[100005], vv[100005];
long long pos1 = 0, pos2 = 0, tem, tem2, l, r, ans, mod = 998244353, tw[100005],
th[100005], ee, loc[1000005], te[100005], vis[1000005], ne[200005],
pr[200005];
long long minn = LONG_MAX, maxx2, posb, mid;
long long c10, c11, c20, c21, dp[100005][11], predp[100005][11], ans1, ans2,
maxx, dis[155][155], edge[155][155], matrix1[105][105], matrix2[105][105],
matrix3[105][105], dist[155];
bool ia, ib;
string s1, s, s2, s3, t1, t2, ss[105];
char ch, ch2, cc2[1005][1005];
vector<long long> v[1000005];
pair<long long, long long> p1, p2;
map<long long, long long> mp;
long long fpow(long long aa, long long bb) {
if (bb == 0) {
return 1;
} else if (bb < 0) {
return 0;
}
long long kk1 = aa;
long long kk2 = 1;
while (bb > 1) {
if (bb % 2) {
kk2 *= kk1;
kk2 %= mod;
}
kk1 *= kk1;
kk1 %= mod;
bb = bb / 2;
}
return (kk1 * kk2) % mod;
}
long long co(long long x, long long y) {
long long ans = 1;
long long ans2 = 1;
if (x == y || y == 0) {
return 1;
} else {
for (long long i = x - y + 1; i <= x; i++) {
ans = ans * i;
ans = ans % mod;
}
for (long long i = 1; i <= y; i++) {
ans2 = ans2 * i;
ans2 = ans2 % mod;
}
ans2 = fpow(ans2, mod - 2);
ans2 = (ans2 * ans) % mod;
return ans2;
}
}
long long summ(long long x) {
long long ans = 0, pos = 0;
long long maxx;
x++;
long long xx = x;
for (long long i = 0;; i++) {
if (tw[i] > x) {
maxx = i;
break;
}
}
for (long long i = maxx - 1; i >= 0; i--) {
if (xx >= tw[i]) {
th[i] = 1;
xx -= tw[i];
} else {
th[i] = 0;
}
}
for (long long i = maxx - 1; i >= 0; i--) {
if (th[i]) {
ans += v[i][pos];
pos = 2 * pos + 2;
} else {
pos *= 2;
}
}
return ans;
}
void modify(long long x, long long m) {
v[0][x] += m;
for (long long i = 1; i <= cnt2; i++) {
v[i][x / 2] += m;
x /= 2;
}
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
x = k;
cnt = 0;
for (long long i = 2; i <= sqrt(x); i++) {
if (x % i == 0) {
b[cnt] = i;
while (x % i == 0) {
x /= i;
c[cnt]++;
}
cnt++;
}
}
if (x > 1) {
b[cnt] = x;
c[cnt] = 1;
cnt++;
}
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < cnt; j++) {
while (a[i] % b[j] == 0) {
a[i] /= b[j];
dp[i][j]++;
}
}
}
for (long long j = 0; j < cnt; j++) {
predp[0][j] = 0;
for (long long i = 1; i <= n; i++) {
predp[i][j] = predp[i - 1][j] + dp[i][j];
}
}
ans = 0;
for (long long i = 1; i <= n; i++) {
d = 1;
for (long long j = 0; j < cnt; j++) {
if (predp[n][j] - predp[i - 1][j] < c[j]) {
d = 0;
break;
}
}
if (d) {
l = i;
r = n;
while (l < r) {
mid = (l + r) / 2;
d = 1;
for (long long j = 0; j < cnt; j++) {
if (predp[mid][j] - predp[i - 1][j] < c[j]) {
d = 0;
break;
}
}
if (d) {
r = mid;
} else {
l = mid + 1;
}
}
ans += (n - l + 1);
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long val;
int ind;
bool present;
bool operator<(const node &a) const {
if (this->val != a.val) return this->val < a.val;
return (!a.present && this->present);
}
};
struct node_res {
int ind;
int s;
int e;
bool operator<(const node_res &a) const { return this->ind < a.ind; }
};
int n, m;
vector<node> vet;
vector<node_res> res;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
node aux;
aux.ind = i;
scanf("%I64d %d", &aux.val, &aux.present);
vet.push_back(aux);
}
sort(vet.begin(), vet.end());
int pr = -1, pl = -1, num = 1;
for (int i = 0; i < vet.size(); i++) {
node_res aux;
aux.ind = vet[i].ind;
if (vet[i].present) {
aux.s = 1;
aux.e = ++num;
res.push_back(aux);
if (pr == -1 && num >= 3) {
pr = num;
pl = 2;
}
} else {
if (pl == -1 || pr == -1) return cout << -1 << endl, 0;
aux.s = pl;
aux.e = pr;
res.push_back(aux);
if (++pl == pr) {
(pr == num) ? pr = -1 : pr++, pl = 2;
}
}
}
sort(res.begin(), res.end());
for (int i = 0; i < res.size(); i++) {
printf("%d %d\n", res[i].s, res[i].e);
}
return 0;
}
| 4 |
#include<iostream>
using namespace std;
int main() {
long long x,a,b;
cin >> x >> a >> b;
if(b <= a) cout << "delicious";
else if(b <= a+x) cout << "safe";
else cout << "dangerous";
return 0;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int INT = 1e9;
const ll LINF = 1e18;
void solve(){
int n,m; cin >> n >> m;
vector<pll> p(n);
for(int i = 0; i < n;i++){
ll x,y; cin >> x >> y;
p[i] = {x,y};
}
sort(p.begin(),p.end());
for(int i = 0; i < m;i++){
int x1,y1,x2,y2; cin >> x1 >> y1 >> x2 >> y2;
ll xl = lower_bound(p.begin(), p.end(), pll(x1,-LINF)) - p.begin();
ll xr = upper_bound(p.begin(),p.end(),pll(x2,LINF)) - p.begin();
ll ans = 0;
for(ll j = xl; j < xr;j++){
if(y1 <= p[j].second && p[j].second <= y2) ans++;
}
cout << ans << endl;
}
}
int main(void){
cin.tie(0); ios_base::sync_with_stdio(false);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 2e5 + 50;
const int inf = 1e9;
int prime[17] = {2, 3, 5, 7, 11, 13, 17, 19, 23,
29, 31, 37, 39, 41, 43, 47, 53};
int dp[105][1 << 17], pre[105][1 << 17], num[105][1 << 17];
int sta[70];
int a[150];
void dfs(int pos, int st) {
if (pos == 1) {
cout << pre[pos][st] << " ";
return;
}
dfs(pos - 1, st ^ (sta[pre[pos][st]]));
cout << pre[pos][st] << " ";
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 2; i < 60; i++) {
for (int j = 0; j < 17; j++) {
if (i % prime[j] == 0) sta[i] |= (1 << j);
}
}
for (int i = 0; i < 105; i++) {
for (int j = 0; j < (1 << 17); j++) dp[i][j] = inf;
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << 17); j++) {
if (dp[i][j] == inf) continue;
for (int k = 1; k < 60; k++) {
if (j & sta[k]) continue;
int now = j | sta[k];
if (dp[i + 1][now] > dp[i][j] + abs(a[i] - k)) {
dp[i + 1][now] = dp[i][j] + abs(a[i] - k);
pre[i + 1][now] = k;
}
}
}
}
int st;
int mx = inf;
for (int i = 0; i < (1 << 17); i++) {
if (dp[n][i] < mx) {
mx = dp[n][i];
st = i;
}
}
dfs(n, st);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int id, dest, direction, capacity;
} edge_t;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m, a, b, c;
cin >> n >> m;
vector<vector<edge_t>> graph(n);
vector<int> directions(m, -1);
vector<int> flows(n, 0);
for (int i = 0; i != m; ++i) {
cin >> a >> b >> c;
--a;
--b;
flows[a] += c;
flows[b] += c;
graph[a].push_back({i, b, 0, c});
graph[b].push_back({i, a, 1, c});
}
for (int i = 0; i != n; ++i) flows[i] >>= 1;
queue<int> q;
q.push(0);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i != graph[u].size(); ++i) {
edge_t edge = graph[u][i];
int id = edge.id;
if (directions[id] == -1) {
directions[id] = edge.direction;
int dest = edge.dest;
flows[dest] -= edge.capacity;
if (dest != n - 1 && !flows[dest]) q.push(dest);
}
}
}
for (int i = 0; i != m; ++i) cout << directions[i] << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
int dblcmp(double d) {
if (fabs(d) < eps) return 0;
return d > eps ? 1 : -1;
}
map<string, long long> w, h, tp, bd, sp;
map<string, vector<string> > a;
set<string> st;
string s;
pair<long long, long long> calc(string v) {
if (w.find(v) != w.end()) {
return make_pair(w[v], h[v]);
}
if (a[v].empty()) {
return make_pair(w[v] = 0, h[v] = 0);
}
if (tp[v] == 1) {
w[v] = h[v] = 0;
for (__typeof(a[v].begin()) e = a[v].begin(); e != a[v].end(); ++e) {
pair<long long, long long> sd = calc(*e);
w[v] += sd.first;
h[v] = max(h[v], sd.second);
}
w[v] += ((int)((a[v]).size()) - 1) * sp[v];
w[v] += 2 * bd[v];
h[v] += 2 * bd[v];
} else {
w[v] = h[v] = 0;
for (__typeof(a[v].begin()) e = a[v].begin(); e != a[v].end(); ++e) {
pair<long long, long long> sd = calc(*e);
w[v] = max(w[v], sd.first);
h[v] += sd.second;
}
h[v] += ((int)((a[v]).size()) - 1) * sp[v];
w[v] += 2 * bd[v];
h[v] += 2 * bd[v];
}
return make_pair(w[v], h[v]);
}
int main() {
int i, j, k, it, t;
scanf("%d", &t);
getchar();
while (t--) {
getline(cin, s);
if (count(s.begin(), s.end(), ',')) {
replace(s.begin(), s.end(), '(', ' ');
replace(s.begin(), s.end(), ')', ' ');
replace(s.begin(), s.end(), ',', ' ');
stringstream ss(s);
string wd, b;
long long x, y;
ss >> wd >> b >> x >> y;
st.insert(b);
w[b] = x;
h[b] = y;
} else if (s[0] == 'H' && !count(s.begin(), s.end(), '.')) {
stringstream ss(s);
string wd, b;
ss >> wd >> b;
st.insert(b);
tp[b] = 1;
} else if (s[0] == 'V' && !count(s.begin(), s.end(), '.')) {
stringstream ss(s);
string wd, b;
ss >> wd >> b;
st.insert(b);
tp[b] = 2;
} else {
if (strstr(s.c_str(), ".pack")) {
replace(s.begin(), s.end(), '(', ' ');
replace(s.begin(), s.end(), ')', ' ');
replace(s.begin(), s.end(), '.', ' ');
stringstream ss(s);
string wb, wc, b;
ss >> wb >> wc >> b;
st.insert(wb);
st.insert(b);
a[wb].push_back(b);
} else if (strstr(s.c_str(), "set_border")) {
replace(s.begin(), s.end(), '(', ' ');
replace(s.begin(), s.end(), ')', ' ');
replace(s.begin(), s.end(), '.', ' ');
stringstream ss(s);
string wb, wc;
long long b;
ss >> wb >> wc >> b;
st.insert(wb);
bd[wb] = (b);
} else if (strstr(s.c_str(), "set_spacing")) {
replace(s.begin(), s.end(), '(', ' ');
replace(s.begin(), s.end(), ')', ' ');
replace(s.begin(), s.end(), '.', ' ');
stringstream ss(s);
string wb, wc;
long long b;
ss >> wb >> wc >> b;
st.insert(wb);
sp[wb] = (b);
}
}
}
for (__typeof(st.begin()) e = st.begin(); e != st.end(); ++e) {
calc(*e);
cout << *e << " " << w[*e] << " " << h[*e] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void rua() {
int a1, a2, k1, k2, n;
scanf("%d%d%d%d%d", &a1, &a2, &k1, &k2, &n);
int mn, mx, tmp, kk;
int nn = n;
if (k1 < k2) {
tmp = nn / k1;
kk = min(tmp, a1);
mx = kk;
nn -= kk * k1;
mx += min(nn / k2, a2);
k1--;
k2--;
tmp = k1 * a1 + k2 * a2;
mn = max(0, n - tmp);
printf("%d %d\n", mn, mx);
return;
} else if (k1 > k2) {
tmp = n / k2;
kk = min(tmp, a2);
mx = kk;
n -= kk * k2;
mx += min(n / k1, a1);
k1--;
k2--;
tmp = k1 * a1 + k2 * a2;
mn = max(0, nn - tmp);
printf("%d %d\n", mn, mx);
return;
} else {
mx = min(n / k1, a1 + a2);
k1--;
k2--;
tmp = k1 * a1 + k2 * a2;
mn = max(0, n - tmp);
printf("%d %d\n", mn, mx);
return;
}
}
int main() {
rua();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int H, W, K;
cin >> H >> W >> K;
vector<string> s(H);
vector<int> cnt(H);
for (int i = 0; i < H; i++) {
cin >> s[i];
cnt[i] = count(s[i].begin(), s[i].end(), '#');
}
int it = 1;
vector<vector<int>> A(H, vector<int>(W));
for (int i = 0; i < H; ) {
int lb = i;
while (i < H && cnt[i] == 0) ++i;
++i;
while (i < H && cnt[i] == 0) ++i;
int ub = i;
vector<int> sum(W);
for (int j = 0; j < W; j++) {
int cc = 0;
for (int k = lb; k < ub; k++) {
cc += s[k][j] == '#';
}
sum[j] = cc;
}
for (int j = 0; j < W;) {
int l2 = j;
while (j < W && sum[j] == 0) ++j;
++j;
while (j < W && sum[j] == 0) ++j;
int r2 = j;
for (int x = lb; x < ub; x++) {
for (int y = l2; y < r2; y++) {
A[x][y] = it;
}
}
++it;
}
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cout << A[i][j] << " \n"[j + 1 == W];
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
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; }
int main() {
long long n;
cin >> n;
if (n == 1)
cout << 1 << endl;
else {
long long ans = 1;
for (int i = 0; i < (7); i++)
if (n - i - 1 >= 1) {
for (int a = 1; a <= n; a++)
ans = max(ans, lcm((n - i) * (n - i - 1), a));
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, p, t, i, j, k, x, y, z, a, b, c, l, r, lst, ans, mn = 1,
ind_mn = -1, mx;
int main() {
cin >> n >> m;
cout << "1 1\n";
for (i = 1; i <= n / 2; i++) {
l = 1;
r = m;
p = n - i + 1;
for (j = 1; j <= m; j++) {
cout << p << " " << r << "\n";
l++;
if (j != m) {
cout << i << " " << l << "\n";
r--;
} else {
if (i + 1 <= (n + 1) / 2) {
cout << i + 1 << " "
<< "1\n";
}
}
}
}
j = i;
if (n % 2 == 1) {
l = 1;
r = m;
for (i = 1; i <= m / 2; i++) {
cout << j << " " << r << "\n";
l++;
if (i != m / 2 || m % 2 == 1) {
cout << j << " " << l << "\n";
r--;
}
}
}
}
| 2 |
#include<iostream>
#include<string>
using namespace std;
int main()
{
string a;
cin>>a;
if(a=="hi"||a=="hihi"||a=="hihihi"||a=="hihihihi"||a=="hihihihihi")
cout<<"Yes";
else
cout<<"No";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int maxh = 210;
int n, h, e, f;
int l[maxh<<1], in_deg[maxh<<1], out_deg[maxh<<1], vis[maxh<<1];
struct Edge {
int v, x;
} E[(maxn<<1)+(maxh<<2)];
inline void addEdge(int u, int v) {
E[e].v = v, E[e].x = l[u], l[u] = e++;
}
void dfs(int u) {
vis[u] = 1;
if (in_deg[u] != out_deg[u]) f = 1;
for (int p = l[u]; p >= 0; p = E[p].x) {
int v = E[p].v;
if (!vis[v]) dfs(v);
}
}
int main() {
memset(l, -1, sizeof(l));
scanf("%d%d", &n, &h);
for (int i = 1; i <= n; i++) {
int a, b, c, d; scanf("%d%d%d%d", &a, &b, &c, &d);
int u, v;
if (c) u = c+h;
else u = a;
if (d) v = d;
else v = b+h;
addEdge(u, v), addEdge(v, u);
++ in_deg[v], ++ out_deg[u];
}
int ok = 1;
for (int i = 1; i <= h; i++) {
if (in_deg[i] > out_deg[i]) ok = 0;
if (in_deg[i+h] < out_deg[i+h]) ok = 0;
}
for (int i = 1; i <= 2*h; i++) {
if ((in_deg[i] || out_deg[i]) && !vis[i]) {
f = 0;
dfs(i);
if (!f) ok = 0;
}
}
if (ok) puts("YES");
else puts("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, i, t, j, k, f, m;
cin >> t;
while (t--) {
cin >> n;
vector<int> a(n);
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 1; i < n - 1; i += 2) {
if (a[i] > a[i - 1] && a[i] > a[i + 1])
continue;
else if (a[i] < a[i - 1] && a[i] < a[i + 1])
continue;
else {
if (a[i] < a[i - 1]) {
if (a[i + 1] * (-1) > a[i])
a[i + 1] *= -1;
else
a[i] *= -1;
} else if (a[i] > a[i - 1]) {
if (a[i + 1] * -1 < a[i])
a[i + 1] *= -1;
else
a[i] *= -1;
}
}
}
for (i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t, a, b, i;
long long q;
long double p, res, pom, h, w;
int main() {
cin >> t;
for (i = 0; i < t; ++i) {
cin >> a >> b;
if (b == 0) {
cout << "1" << endl;
continue;
}
if (a == 0) {
cout << "0.5" << endl;
continue;
}
q = (long long)a * b;
p = q;
w = (double)a / 4;
if (w > b)
pom = (long long)a * b - (long long)b * b * 2;
else
pom = w * a / 2;
p += pom;
res = p / q;
cout << res / 2 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, x;
cin >> n >> x;
long long arr[n];
for (int j = 0; j < n; j++) cin >> arr[j];
sort(arr, arr + n);
long long count = 0, sum = 0;
int j;
for (j = n - 1; j >= 0; j--) {
sum += arr[j];
count++;
if ((double)sum / count < x) break;
}
if (j == -1)
cout << n << endl;
else
cout << count - 1 << endl;
}
}
| 2 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int h, w, d; cin >> h >> w >> d;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
int x = ((i + j) / d % 2 + 2) % 2;
int y = ((i + w - j) / d % 2 + 2) % 2;
cout << "RYGB"[x << 1 | y];
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 5;
const int INF = (int)1e9;
int cnt[MAXN];
int ans[MAXN];
int n, m;
int f(int x) {
int ret = 0;
for (int i = 1; i <= x; ++i) {
ret += max(0, x - 2 * i);
}
return ret;
}
void solve() {
scanf("%d %d", &n, &m);
if (f(n) < m) {
printf("-1\n");
return;
}
int p = 0;
while (p + 1 <= n && f(p + 1) <= m) {
++p;
}
for (int i = 1; i <= p; ++i) {
ans[i] = i;
}
m -= f(p);
for (int i = 1; i <= p; ++i) {
for (int j = i + 1; j <= p; ++j) {
++cnt[i + j];
}
}
int g = p;
while (m > 0) {
++g;
while (cnt[g] > m) {
++g;
}
m -= cnt[g];
ans[++p] = g;
for (int i = 1; i < p; ++i) {
++cnt[ans[i] + ans[p]];
}
}
assert(p <= n);
for (int i = 1; i <= n; ++i) {
if (i <= p) {
printf("%d ", ans[i]);
} else {
printf("%d ", INF - (n - i) * 100000);
}
}
}
int main() {
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
| 5 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<iomanip>
using namespace std;
const int INF = 1e9+100;
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
vector<vector<int> > field;
vector<pair<int,int> > in;
vector<int> x, y;
int n, m, a, b;
int x1, x2, y1, y2;
cin>>n>>m;
for(int i = 0; i < n; i++){
cin>>a>>b;
x.push_back(a);
y.push_back(b);
in.push_back(make_pair(b,a));
}
x.push_back(INF);
x.push_back(-INF);
y.push_back(INF);
y.push_back(-INF);
sort(x.begin(), x.end());
sort(y.begin(), y.end());
sort(in.begin(), in.end());
x.erase(unique(x.begin(), x.end()), x.end());
y.erase(unique(y.begin(), y.end()), y.end());
field.resize(y.size()+4, vector<int>(x.size()+4, 0));
for(int i = 0; i < in.size(); i++){
int xkey = in[i].second, ykey = in[i].first;
int tx = lower_bound(x.begin(), x.end(), xkey) - x.begin();
int ty = lower_bound(y.begin(), y.end(), ykey) - y.begin();
field[ty][tx]++;
}
for(int i = 0; i < y.size(); i++){
for(int j = 0; j < x.size(); j++){
field[i+1][j] += field[i][j];
}
}
for(int j = 0; j < x.size(); j++){
for(int i = 0; i < y.size(); i++){
field[i][j+1] += field[i][j];
}
}
for(int i = 0; i < m; i++){
cin>>x1>>y1>>x2>>y2;
int tx1l = lower_bound(x.begin(), x.end(), x1) - x.begin();
int ty1l = lower_bound(y.begin(), y.end(), y1) - y.begin();
int tx2u = upper_bound(x.begin(), x.end(), x2) - x.begin();
int ty2u = upper_bound(y.begin(), y.end(), y2) - y.begin();
int ans = field[ty2u-1][tx2u-1] + field[ty1l-1][tx1l-1] - field[ty2u-1][tx1l-1] - field[ty1l-1][tx2u-1];
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string line;
getline(cin, line);
int k = 0, n = line.size();
for (; k < n; k++)
if (line[k] == '^') break;
long long left = 0, right = 0;
for (int i = 0; i < (int)(k); i++)
if (line[i] != '=') left += (line[i] - '0') * (k - i);
for (int i = 0; i < (int)(n - k - 1); i++)
if (line[k + i + 1] != '=') right += (line[k + i + 1] - '0') * (i + 1);
printf("%s\n", left > right ? "left" : right > left ? "right" : "balance");
}
int main() {
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, f_cnt = 0, d[1000010] = {0}, ans = 0;
char s[1000010];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] == 'F') {
++f_cnt;
if (i > f_cnt) {
if (d[f_cnt - 1] >= i - f_cnt) {
d[f_cnt] = d[f_cnt - 1] + 1;
} else
d[f_cnt] = i - f_cnt;
}
ans = max(ans, d[f_cnt]);
}
}
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 2e5 + 5;
int N;
long long dp[MN][2], good[MN];
vector<long long> pref[MN], suf[MN];
vector<int> g[MN];
void solve(int u) {
good[u] = 1;
if (g[u].empty()) {
dp[u][0] = 1;
return;
}
long long p2 = 1;
pref[u].push_back(1);
for (int v : g[u]) {
solve(v);
pref[u].push_back(pref[u].back() * good[v] % 998244353);
}
suf[u].push_back(1);
for (int i = (int)g[u].size() - 1; i >= 0; i--)
suf[u].push_back(suf[u].back() * good[g[u][i]] % 998244353);
reverse(suf[u].begin(), suf[u].end());
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
good[u] = good[u] * good[v] % 998244353;
long long t = pref[u][i] * suf[u][i + 1] % 998244353 *
(dp[v][0] + dp[v][1]) % 998244353;
dp[u][1] = (dp[u][1] + t) % 998244353;
long long val = dp[u][0] * (dp[v][0] + dp[v][1]) % 998244353;
val = (val + dp[u][0] * good[v]) % 998244353;
val = (val + p2 * (dp[v][0] + dp[v][1])) % 998244353;
dp[u][0] = val;
p2 = p2 * good[v] % 998244353;
}
dp[u][0] = (dp[u][0] - dp[u][1] + 998244353) % 998244353;
good[u] = (good[u] + dp[u][0]) % 998244353;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 2; i <= N; i++) {
int p;
cin >> p;
g[p].push_back(i);
}
solve(1);
cout << good[1] << '\n';
}
| 6 |
#include<iostream>
#include<vector>
#define INF 10000000
using namespace std;
vector<vector<int> > cost;
vector<int> mincost;
int s,d;
int prim(){
vector<bool> used(d+1,false);
mincost[0]=0;
int res=0;
while(1){
int v=-1;
for(int u=0;u<d+1;u++){
if(!used[u]&&(v==-1||mincost[u]<mincost[v])){
v=u;
}
}
if(v==-1)
break;
used[v]=true;
res+=mincost[v];
for(int u=0;u<d+1;u++){
mincost[u]=min(mincost[u],cost[v][u]);
}
}
return res;
}
int main(){
while(cin>>s>>d,s||d){
cost=vector<vector<int> >(d+1,vector<int>(d+1,INF));
mincost=vector<int>(d+1,INF);
for(int i=0;i<s;i++){
for(int j=0;j<d;j++){
int x;
cin>>x;
if(!x)
continue;
cost[d][j]=min(cost[d][j],x);
cost[j][d]=min(cost[d][j],x);
}
}
for(int i=0;i<d-1;i++){
for(int j=1;j<d-i;j++){
int x;
cin>>x;
if(!x)
continue;
cost[i][i+j]=x;
cost[i+j][i]=x;
}
}
cout<<prim()<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define ll long long
int main(){
ll n,x;
cin >> n >> x;
ll a[n];
rep(i,n)cin>>a[i];
sort(a,a+n);
ll sum=0;
rep(i,n){
sum+=a[i];
if(sum>x){cout << i << endl;return 0;}
}
if(sum==x)cout << n << endl;
else cout << n-1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 1;
const int INF = 0x3f3f3f3f;
const int MOD = 1000000007;
int n, h, ans[N], a[N], b[N];
struct pos {
int ix, a;
};
pos p[N];
bool cmp(const pos &a, const pos &b) { return a.a < b.a; }
int main() {
scanf("%d%d", &n, &h);
for (int i = 0; i < n; ++i) {
scanf("%d", &p[i].a);
p[i].ix = i;
}
sort(p, p + n, cmp);
for (int i = 0; i < n; ++i) ans[i] = 1;
if (n < 6) {
int cur = INF;
for (int i = 0; i < (1 << n); ++i) {
int ca = 0, cb = 0;
for (int j = 0; j < n; ++j) {
if ((i & (1 << j)) == (1 << j))
a[ca++] = p[j].a;
else
b[cb++] = p[j].a;
}
int maxn = -1, minn = INF;
if (ca && cb) {
minn = min(minn, a[0] + b[0] + h);
maxn = max(maxn, a[ca - 1] + b[cb - 1] + h);
}
if (ca > 1) {
minn = min(minn, a[0] + a[1]);
maxn = max(maxn, a[ca - 1] + a[ca - 2]);
}
if (cb > 1) {
minn = min(minn, b[0] + b[1]);
maxn = max(maxn, b[cb - 1] + b[cb - 2]);
}
if (maxn - minn < cur) {
cur = maxn - minn;
for (int j = 0; j < n; ++j) {
if ((i & (1 << j)) == (1 << j))
ans[p[j].ix] = 1;
else
ans[p[j].ix] = 2;
}
}
}
printf("%d\n", cur);
} else {
int cur = p[n - 1].a + p[n - 2].a - p[1].a - p[0].a;
int maxn = -1, minn = p[0].a + p[1].a + h;
maxn = max(maxn, p[n - 1].a + p[n - 2].a);
maxn = max(maxn, p[n - 1].a + p[0].a + h);
minn = min(minn, p[1].a + p[2].a);
if (maxn - minn < cur) {
cur = maxn - minn;
ans[p[0].ix] = 2;
}
if (1) {
int ed = -1;
for (int i = 1; i < n - 2; ++i) {
int maxn = p[n - 1].a + p[n - 2].a, minn = p[0].a + p[1].a + h;
maxn = max(maxn, p[n - 1].a + p[i].a + h);
minn = min(minn, p[i + 1].a + p[0].a);
if (i > 1) minn = min(minn, p[1].a + p[2].a);
if (maxn - minn < cur) {
cur = maxn - minn;
ans[p[0].ix] = 1;
ed = i;
}
}
if (~ed)
for (int i = 1; i <= ed; ++i) ans[p[i].ix] = 2;
}
printf("%d\n", cur);
}
for (int i = 0; i < n; ++i) {
printf("%d", ans[i]);
printf(i == n - 1 ? "\n" : " ");
}
return 0;
}
| 2 |
#include<stdio.h>
char f[6][6],s[6],i,j,a,y,x,p,b;
int main()
{
for(;i<9;++i,b=!b){
scanf("%s",s);
for(j=0;j<4+b;++j){
a=s[j]-48;
f[i/2][j]|=a<<1+b;
f[i/2+b][j+!b]|=a<<3-b*3;
}
}
do{
while(!((f[y][x]>>(p=(p+1)%4))&1));
putchar("URDL"[p]);
x+=p?2-p:0;
y+=p==3?0:p-1;
p=(p+2)%4;
}while(y|x|f[0][0]==6&p==3);
return!puts("");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int maxSubArraySum(vector<long long int> a, long long int size) {
long long int max_so_far = INT_MIN, max_ending_here = 0;
for (long long int i = 0; i < size; i++) {
max_ending_here = max_ending_here + a[i];
if (max_so_far < max_ending_here) max_so_far = max_ending_here;
if (max_ending_here < 0) max_ending_here = 0;
}
return max_so_far;
}
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, ans = 0;
cin >> n;
long long int ar[n];
vector<long long int> x, y;
for (long long int i = 0; i < n; i++) cin >> ar[i];
for (long long int i = 0; i < n; i++)
if (i % 2 == 0) {
if (i) x.push_back(-ar[i] + ar[i - 1]);
if (i != n - 1) y.push_back(-ar[i] + ar[i + 1]);
ans += ar[i];
}
ans +=
max(0LL, max(maxSubArraySum(x, x.size()), maxSubArraySum(y, y.size())));
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int long long test = 1;
while (test--) {
int long long n;
cin >> n;
int long long a[n];
map<int long long, int long long> m;
for (int long long i = 0; i < n; i++) {
cin >> a[i];
m[a[i] - i] += a[i];
}
int long long t = 0;
for (auto u : m) {
t = max(t, u.second);
}
cout << t;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int arr[100001] = {0};
int bitwise[100001] = {0};
int n, x, a, m = 0;
scanf("%d %d", &n, &x);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (arr[a] == 0)
arr[a] = 1;
else {
printf("0");
return 0;
}
}
for (int a = 0; a < 100001; a++)
if (arr[a] == 1 && (a & x) != a) {
if (bitwise[a & x] == 0)
bitwise[a & x] = 1;
else
m = 1;
}
for (int i = 0; i < 100001; i++) {
if (arr[i] == 1 && bitwise[i] == 1) {
printf("1");
return 0;
}
}
if (m == 1)
printf("2");
else
printf("-1");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, d[1000005];
int fun(int x) {
if (x == 0) return 0;
if (x == 1) return 1;
if (x == 2) return 0;
if (x == 3) return 1;
if (x % 2) return 0;
int two = 0;
while (x % 2 == 0) {
two++;
x /= 2;
}
if (x == 3) two++;
if (two % 2)
return 1;
else
return 2;
}
int fun2(int x) {
if (x == 0) return 0;
if (x == 1) return 1;
if (x == 2) return 2;
if (x % 2)
return 0;
else
return 1;
}
int main() {
scanf("%d %d", &n, &k);
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &d[i]);
sum ^= fun2(d[i]);
}
if (k % 2 == 0) {
if (sum == 0)
printf("Nicky\n");
else
printf("Kevin\n");
return 0;
}
int zor = 0;
for (int i = 1; i <= n; i++) zor ^= fun(d[i]);
if (zor == 0)
printf("Nicky\n");
else
printf("Kevin\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[200005],b[200005];
long long s1,s2;
int main()
{
int n;
cin>>n;
for(int i=0;i<n;i++)
cin>>a[i];
for(int i=0;i<n;i++)
cin>>b[i];
for(int i=0;i<n;i++)
{
s1+=a[i];
s2+=b[i];
}
if(s1<s2)
{
cout<<"-1";
return 0;
}
long long x=0,cnt=0;
vector<long long>v;
for(int i=0;i<n;i++)
{
if(a[i]<b[i])
{
x+=b[i]-a[i];
cnt++;
}
else
v.push_back(a[i]-b[i]);
}
sort(v.begin(),v.end(),greater<long long>());
for(int i=0;i<v.size();i++)
{
if(x>0)
{
x-=v[i];
cnt++;
}
}
cout<<cnt;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
vector<int> nxt(n);
for (int &i : v) {
cin >> i;
}
vector<pair<int, int>> v1(n);
for (int i = 0; i < n; i++) {
v1[i] = make_pair(v[i], i);
}
sort(v1.begin(), v1.end());
for (int i = 0; i < n; i++) {
nxt[v1[i].second] = i;
}
bool same = false;
for (int i = 0; i < n - 1; i++) {
if (v1[i].first == v1[i + 1].first) same = true;
}
vector<int> vis(n);
int countcycle = 0;
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
if (nxt[i] != i) {
int countlen = 0;
while (nxt[i] != i && !vis[i]) {
vis[i] = 1;
countlen++;
i = nxt[i];
}
if (countlen % 2 == 0) countcycle++;
}
}
cout << (((countcycle % 2 == 0) || same) ? "YES" : "NO") << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1000], b[1000], i, j, n, l, k, tmp = 9, temp;
cin >> n >> l;
for (i = 0; i < n; i++) {
cin >> a[i];
if (i == 0) tmp = a[0];
if (i != 0) a[i - 1] = a[i] - a[i - 1];
}
a[n - 1] = (tmp + l - a[n - 1]);
for (i = 0; i < n; i++) {
cin >> b[i];
if (i == 0) tmp = b[i];
if (i != 0) b[i - 1] = b[i] - b[i - 1];
}
b[i - 1] = (tmp + l - b[i - 1]);
for (i = 0; i < n; i++) {
for (j = i, k = 0; k < n; k++, j = (j + 1) % n) {
if (a[j] != b[k]) break;
}
if (k == n) break;
}
if (i < n)
cout << "YES";
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int dir[][2] = {{0, 1}, {1, 1}, {1, 0}, {1, -1},
{0, -1}, {-1, -1}, {-1, 0}, {-1, 1}};
int n;
vector<bool> states;
int encode(int i, int j, int s, int d) {
return d + 8 * (s + states.size() * (j + 310 * i));
}
tuple<int, int, int, int> decode(int x) {
int d = x % 8;
x /= 8;
int s = x % states.size();
x /= states.size();
int j = x % 310;
x /= 310;
int i = x;
return make_tuple(i, j, s, d);
}
int main() {
scanf("%d", &n);
vector<int> t(n);
for (int &x : t) scanf("%d", &x);
states.clear();
for (int x : t) {
states.push_back(true);
while (--x) states.push_back(false);
}
vector<bool> mark(310 * 310 * states.size() * 8, false);
queue<int> Q;
int init = encode(155, 155, 0, 0);
mark[init] = true;
Q.push(init);
auto insert = [&](int i, int j, int s, int d) {
int state = encode(i + dir[d][0], j + dir[d][1], s, d);
if (!mark[state]) {
mark[state] = true;
Q.push(state);
}
};
while (!Q.empty()) {
int i, j, s, d;
tie(i, j, s, d) = decode(Q.front());
Q.pop();
if (s == states.size() - 1) continue;
if (states[s + 1]) {
insert(i, j, s + 1, (d + 1) % 8);
insert(i, j, s + 1, (d + 7) % 8);
} else
insert(i, j, s + 1, d);
}
int ans = 0;
for (int i = 0; i < 310; i++)
for (int j = 0; j < 310; j++) {
bool found = false;
if (!found)
for (int s = 0; s < states.size(); s++)
if (!found)
for (int d = 0; d < 8; d++)
if (mark[encode(i, j, s, d)]) found = true;
if (found) ans++;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<pair<long long int, long long int> > s;
set<pair<long long int, long long int> >::iterator it1, it2, it3;
vector<pair<long long int, long long int> > v;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t, n, m, q, i, j, k, x, y, z;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
s.insert(make_pair(x, i));
}
it2 = s.begin();
it1 = it2;
it2++;
while (it1 != s.end() && it2 != s.end()) {
if ((*it1).first == (*it2).first) {
x = (*it1).first;
y = (*it2).second;
s.insert(make_pair(2 * x, y));
it3 = it2;
it3++;
s.erase(it1);
s.erase(it2);
it2 = it3;
}
it1 = it2;
it2++;
}
it1 = s.begin();
while (it1 != s.end()) {
v.push_back(make_pair(it1->second, it1->first));
it1++;
}
sort(v.begin(), v.end());
cout << v.size() << "\n";
for (i = 0; i < v.size(); i++) {
cout << v[i].second << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long dp[5005][5005], n, bagi = 1e9 + 7;
char c[5005];
long long f(long long idx, long long y) {
if (idx == n) {
return 1;
} else if (y < 1) {
return 0;
} else if (dp[idx][y] == -1) {
if (c[idx] == 'f') {
dp[idx][y] = (f(idx + 1, y + 1)) % bagi;
} else {
dp[idx][y] = (f(idx + 1, y) + f(idx, y - 1)) % bagi;
}
}
return dp[idx][y];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> c[i];
}
memset(dp, -1, sizeof(dp));
cout << f(1, 1) % bagi << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s = 1, t = 1, b = 0;
char c;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> c;
if (c == '.') {
if (b == 1) break;
t++;
} else if (c == 'R') {
t++;
b = 1;
} else
break;
}
s = t - 1;
if (b == 0) {
t--;
s++;
}
cout << s << ' ' << t << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int e[501][501];
void dfs(int l,int r,int col)
{
if(l==r) return;
int mid=(l+r)/2;
for(int i=l;i<=mid;i++)
for(int j=mid+1;j<=r;j++)
e[i][j]=col,e[j][i]=col;
dfs(l,mid,col+1);
dfs(mid+1,r,col+1);
}
signed main()
{
int n;
scanf("%d",&n);
dfs(1,n,1);
for(int i=1;i<n;i++)
{
for(int j=i+1;j<=n;j++)
printf("%d ",e[i][j]);
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (1e6 + 10);
const long long mod = (1e9 + 7);
const long long inf = (1e6 + 7);
int b[N];
bool f(char ch) {
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
return false;
} else {
return true;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.size();
s = s + "@" + s;
for (int i = 0; i < n; i++) {
if (f(s[i]) && f(s[i + 1]) && f(s[i + 2])) {
if ((s[i] != s[i + 1] && s[i + 1] != s[i + 2] && s[i + 2] != s[i]) ||
(s[i + 1] != s[i + 2]) || (s[i] != s[i + 2])) {
b[i + 1] = 1;
i++;
}
}
}
for (int i = 0; i < n; i++) {
cout << s[i];
if (b[i]) {
cout << " ";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,x;
cin>>n;
for(int times=0;times<n;times++){
cout<<"Case "<<times+1<<':'<<endl;
cin>>x;
for(int i=0;i<10;i++){
x=x*x%1000000/100;
cout<<x<<endl;
}
}
}
| 0 |
#include<bits/stdc++.h>
#define X first
#define Y second
#define pb emplace_back
#define FOR(i,a,b) for(int (i)=(a);i<(b);++(i))
#define EFOR(i,a,b) for(int (i)=(a);i<=(b);++(i))
#define rep(X,Y) for (int (X) = 0;(X) < (Y);++(X))
#define REP rep
#define rrep(X,Y) for (int (X) = (Y)-1;(X) >=0;--(X))
#define all(X) (X).begin(),(X).end()
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef ll LL;
typedef pii PII;
typedef pll PLL;
const ll MOD=1e9+7;
#define rall(X) (X).rbegin(),(X).rend()
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
#define reps(X,S,Y) for (int (X) = S;(X) < (Y);++(X))
#define rreps(X,S,Y) for (int (X) = (Y)-1;(X) >= (S);--(X))
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}
const long long INF = (1ll << 50);
struct graph {
typedef long long flow_type;
struct edge {
int src, dst;
flow_type capacity, flow;
size_t rev;
};
int n;
vector<vector<edge>> adj;
graph(int n) : n(n), adj(n) { }
void add_edge(int src, int dst, flow_type capacity) {
adj[src].push_back({src, dst, capacity, 0, adj[dst].size()});
adj[dst].push_back({dst, src, 0, 0, adj[src].size()-1});
}
flow_type max_flow(int s, int t) {
vector<int> level(n), iter(n);
function<int(void)> levelize = [&]() { // foward levelize
level.assign(n, -1); level[s] = 0;
queue<int> Q; Q.push(s);
while (!Q.empty()) {
int u = Q.front(); Q.pop();
if (u == t) break;
for (auto &e: adj[u]) {
if (e.capacity > e.flow && level[e.dst] < 0) {
Q.push(e.dst);
level[e.dst] = level[u] + 1;
}
}
}
return level[t];
};
function<flow_type(int, flow_type)> augment = [&](int u, flow_type cur) {
if (u == t) return cur;
for (int &i = iter[u]; i < adj[u].size(); ++i) {
edge &e = adj[u][i], &r = adj[e.dst][e.rev];
if (e.capacity > e.flow && level[u] < level[e.dst]) {
flow_type f = augment(e.dst, min(cur, e.capacity - e.flow));
if (f > 0) {
e.flow += f;
r.flow -= f;
return f;
}
}
}
return flow_type(0);
};
for (int u = 0; u < n; ++u) // initialize
for (auto &e: adj[u]) e.flow = 0;
flow_type flow = 0;
while (levelize() >= 0) {
fill(all(iter), 0);
for (flow_type f; (f = augment(s, INF)) > 0; )
flow += f;
}
return flow;
}
};
int H;
int W;
char field[114][114];
void Color(vector<vector<int>> &es, vector<int> &col, int v, int c=1) {
col[v] = c;
for (int u : es[v]) {
if (col[u]) {
assert(col[u] != col[v]);
continue;
}
Color(es, col, u, 3-c);
}
}
int Solve() {
rep(i, H) {
rep(j, W) {
cin >> field[i][j];
}
}
int ans = 1;
map<pii, pii> hole;
reps(i, 1, H) {
reps(j, 1, W) {
int cnt = 0;
vector<pii> holes;
rep(k, 2) {
rep(l, 2) {
if (field[i-k][j-l] != '#') holes.eb(pii(k, l));
}
}
if (holes.size() == 1) {
ans++;
hole[pii(i, j)] = holes[0];
}
}
}
if (hole.empty()) return ans;
using Seg = pair<pii, pii>;
vector<Seg> segs;
map<Seg, int> mp;
reps(i, 1, H) {
reps(j, 1, W) {
if (!hole.count(pii(i, j))) continue;
auto p = hole[pii(i, j)];
if (p.X) {
reps(ni, i+1, H) {
int cnt = 0;
rep(k, 2) {
rep(l, 2) {
cnt += (field[ni-k][j-l] == '#');
}
}
if (cnt <= 2) break;
if (hole.count(pii(ni, j))) {
if (hole[pii(ni, j)].X == 0) {
segs.eb(Seg(pii(i, j), pii(ni, j)));
int v = mp.size();
mp[segs.back()] = v;
}
break;
}
assert(cnt == 4);
}
}
if (p.Y) {
reps(nj, j+1, W) {
int cnt = 0;
rep(k, 2) {
rep(l, 2) {
cnt += (field[i-k][nj-l] == '#');
}
}
if (cnt <= 2) break;
if (hole.count(pii(i, nj))) {
if (hole[pii(i, nj)].Y == 0) {
segs.eb(Seg(pii(i, j), pii(i, nj)));
int v = mp.size();
mp[segs.back()] = v;
}
break;
}
assert(cnt == 4);
}
}
}
}
vector<vector<int>> es(mp.size());
for (auto &s : segs) {
bool sd = s.X.X == s.Y.X;
for (auto &t : segs) {
bool td = t.X.X == t.Y.X;
if (sd == td) continue;
if (!sd) swap(s, t);
if (min(s.X.Y, s.Y.Y) <= t.X.Y && t.X.Y <= max(s.X.Y, s.Y.Y)) {
if (min(t.X.X, t.Y.X) <= s.X.X && s.X.X <= max(t.X.X, t.Y.X)) {
int u = mp[s];
int v = mp[t];
es[u].eb(v);
es[v].eb(u);
}
}
if (!sd) swap(s, t);
}
}
vector<int> col(mp.size());
rep(v, mp.size()) {
if (col[v]) continue;
Color(es, col, v);
}
//vector<pii> rev(mp.size());
//for (auto &p : mp) {
// rev[p.Y] = p.X;
//}
//rep(v, mp.size()) {
// for (int u : es[v]) {
// if (v > u) continue;
// auto a = rev[v];
// cout << "(" << a.X << ", " << a.Y << "), ";
// auto b = rev[u];
// cout << "(" << b.X << ", " << b.Y << ")" << endl;
// }
//}
int S = mp.size();
int T = mp.size()+1;
graph G(mp.size()+2);
rep(v, mp.size()) {
if (col[v] == 1) {
G.add_edge(S, v, 1);
} else {
G.add_edge(v, T, 1);
}
}
rep(v, mp.size()) {
if (col[v] == 2) continue;
for (int u : es[v]) {
assert(col[u] == 2);
G.add_edge(v, u, 1);
}
}
int m = mp.size();
return ans - (m - G.max_flow(S, T));
}
signed main(){
ios_base::sync_with_stdio(false);
cout<<fixed<<setprecision(0);
while (1) {
cin >> H >> W;
if (H == 0) return 0;
cout << Solve() << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long m, n, d;
string a, b, s;
long long dp[2005][2005];
long long x[2005];
long long digitdp(long long j, long long md, long long l) {
if (l == 10 && dp[j][md] != -1) return dp[j][md];
long long an = 0;
if (j % 2) {
if (j == a.size() - 1) {
if (l >= d && d % m == md)
return 1;
else
return 0;
}
if (d < l)
return dp[j][md] =
digitdp(j + 1, (md + m - d * x[a.size() - 1 - j] % m) % m, 10);
else if (d == l)
return digitdp(j + 1, (md + m - d * x[a.size() - 1 - j] % m) % m,
s[j + 1] - '0');
else
return 0;
} else {
if (j == a.size() - 1) {
for (long long i = 0; i <= l; i++)
if (i != d && i % m == md) an++;
return an;
}
for (long long i = 0; i < l; i++)
if (i != d)
an += digitdp(j + 1, (md + m - i * x[a.size() - 1 - j] % m) % m, 10);
if (l != 10 && l != d)
an += digitdp(j + 1, (md + m - l * x[a.size() - 1 - j] % m) % m,
s[j + 1] - '0');
if (l == 10) dp[j][md] = an % 1000000007;
return an % 1000000007;
}
}
bool chek(string s) {
int md = 0;
for (int i = 0; i < s.size(); i++) {
if (i % 2 && (s[i] - '0') != d) return 0;
if (i % 2 == 0 && (s[i] - '0') == d) return 0;
md += (s[i] - '0') * x[s.size() - 1 - i] % m;
}
if (md % m == 0) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin >> m >> d;
cin >> a >> b;
n = a.size() - 1;
x[0] = 1;
for (long long i = 1; i < a.size(); i++) x[i] = x[i - 1] * 10 % m;
if (a.size() % 2) {
for (long long i = 0; i < 10; i++) dp[a.size() - 1][i % m]++;
dp[a.size() - 1][d % m]--;
} else
dp[a.size() - 1][d % m]++;
for (long long i = 0; i < a.size() - 1; i++)
for (long long j = 0; j < m; j++) dp[i][j] = -1;
s = b;
long long an = digitdp(0, 0, s[0] - '0');
s = a;
an -= digitdp(0, 0, s[0] - '0');
an += chek(a);
an = (an + 1000000007) % 1000000007;
cout << an << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const long long linf = (1ll << 62) - 1;
const int N = 1e5 + 100;
const int T = 1 << 20;
struct table {
long long table[T + 1000];
bool used[T + 1000];
int index[T + 1000];
int find(long long x) {
for (int i = x & (T - 1);; i++) {
if (!used[i]) {
return -1;
}
if (table[i] == x) {
return index[i];
}
}
assert(false);
}
void insert(long long x, int value) {
for (int i = x & (T - 1);; i++) {
if (!used[i]) {
used[i] = true;
table[i] = x;
index[i] = value;
return;
}
if (table[i] == x) {
return;
}
}
}
};
int n;
char s[N];
int m;
string w[N];
long long rnd[N];
inline long long myrand2() { return ((1ll * rand()) << 16) + rand(); }
inline long long myrand() { return (myrand2() << 32) + myrand2(); }
table t;
int parent[N];
inline char lower(char c) {
if ('A' <= c && c <= 'Z') {
return c - 'A' + 'a';
}
return c;
}
int main() {
for (int i = 0; i < N; i++) {
rnd[i] = myrand();
}
cin >> n;
scanf("%s", s);
cin >> m;
int maxlen = 0;
for (int i = 0; i < m; i++) {
static char buf[N];
scanf("%s", buf);
int len = strlen(buf);
reverse(buf, buf + len);
maxlen = max(maxlen, len);
long long h = 0;
for (int j = 0; j < len; j++) {
h ^= rnd[j] * lower(buf[j]);
}
t.insert(h, i);
reverse(buf, buf + len);
w[i] = string(buf);
}
fill_n(parent, n + 1, -1);
parent[0] = 0;
for (int i = 0; i < n; i++) {
if (parent[i] == -1) {
continue;
}
long long h = 0;
for (int j = 1; i + j <= n && j <= maxlen; j++) {
h ^= rnd[j - 1] * lower(s[i + j - 1]);
int index = t.find(h);
if (index == -1) {
continue;
}
if (parent[i + j] == -1) {
parent[i + j] = index;
}
}
}
assert(parent[n] != -1);
vector<int> words;
int cur = n;
while (cur != 0) {
words.push_back(parent[cur]);
assert(parent[cur] != -1);
cur -= ((int)(w[parent[cur]]).size());
}
reverse((words).begin(), (words).end());
for (int i : words) {
printf("%s ", w[i].data());
}
puts("");
return 0;
}
| 3 |
#include <cstdio>
int n,q;
int s[100001];
int search(int key){
int l=0,r=n;
while(r-l>1){
int mid=(l+r)/2;
if(s[mid]>key)r=mid;
else l=mid;
}
return s[l]==key?1:0;
}
int main(void){
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&s[i]);
}
scanf("%d",&q);
int cnt=0;
for(int i=0;i<q;i++){
int t;
scanf("%d",&t);
cnt+=search(t);
}
printf("%d\n",cnt);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
const double eps = 1e-8;
long long read() {
long long s = 0;
char c = getchar(), lc = '+';
while (c < '0' || '9' < c) lc = c, c = getchar();
while ('0' <= c && c <= '9') s = s * 10 + c - '0', c = getchar();
return lc == '-' ? -s : s;
}
void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10)
putchar(x + '0');
else {
write(x / 10);
putchar(x % 10 + '0');
}
}
void print(long long x, char c = '\n') {
write(x);
putchar(c);
}
struct point {
long long x, y;
double xx, yy;
bool operator<(const point &a) const {
if (x == a.x) return y > a.y;
return x < a.x;
}
} a[N];
double p[N * 2];
long long t[N * 2], nn;
void add(long long x) {
for (; x <= nn * 2; x += x & -x) t[x]++;
}
long long query(long long x) {
long long ret = 0;
for (; x; x -= x & -x) ret += t[x];
return ret;
}
signed main() {
memset(t, 0, sizeof(t));
long long n = nn = read(), w = read(), cnt = 0, ans = 0;
for (long long i = 1; i <= n; i++) {
long long x = read(), v = read();
a[i].xx = 1.0 * x / (v - w);
a[i].yy = 1.0 * x / (v + w);
p[++cnt] = a[i].xx;
p[++cnt] = a[i].yy;
}
sort(p + 1, p + 1 + cnt);
cnt = unique(p + 1, p + 1 + cnt) - p - 1;
for (long long i = 1; i <= n; i++) {
a[i].x = lower_bound(p + 1, p + 1 + cnt, a[i].xx) - p;
a[i].y = lower_bound(p + 1, p + 1 + cnt, a[i].yy) - p;
}
sort(a + 1, a + 1 + n);
for (long long i = n; i >= 1; i--) {
ans += query(a[i].y);
add(a[i].y);
}
print(ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int mul_mod(int a, int b, int m) {
int x = 0, y = a;
while (b > 0) {
if (b & 1) {
x = (x + y) % m;
}
y = (y + y) % m;
b >>= 1;
}
return x;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
int n;
cin >> n;
int w[n];
set<pair<int, int> > s, e;
for (int i = 0; i < n; i++) {
cin >> w[i];
e.insert(make_pair(w[i], i));
}
int p[2 * n];
string ord;
cin >> ord;
for (int i = 0; i < 2 * n; i++) {
if (ord[i] == '0') {
pair<int, int> pr = *e.begin();
p[i] = pr.second + 1;
e.erase(e.begin());
s.insert(pr);
} else {
p[i] = s.rbegin()->second + 1;
s.erase(--s.end());
}
}
for (int i = 0; i < 2 * n; i++) cout << p[i] << " ";
return 0;
}
| 2 |
#include<stdio.h>
int a[1000],b[1000],c[1001][1001];
int main(void)
{
int n,m,s,j,i;
scanf("%d %d",&n,&m);
for(i=0;i<n;i++){
scanf("%d",&a[i]);
}
for(i=0;i<m;i++){
scanf("%d",&b[i]);
}
for(i=0;i<=m;i++){
for(j=0;j<=n;j++){
c[i][j]=200000000;
}
}
c[0][0]=0;
for(i=0;i<m;i++){
for(j=0;j<=n;j++){
if(c[i+1][j]>c[i][j]){
c[i+1][j]=c[i][j];
}
if(c[i+1][j+1]>c[i][j]+a[j]*b[i]){
c[i+1][j+1]=c[i][j]+a[j]*b[i];
}
}
}
s=200000000;
for(i=0;i<=m;i++){
if(s>c[i][n]){
s=c[i][n];
}
}
printf("%d\n",s);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long func(int x, int y) { return 100000 * (long long)x + y; }
vector<pair<pair<int, int>, int> > diag[200100], xaxis[200100], yaxis[200100];
int main() {
int i, j, k, n, X, Y;
cin >> n;
int x[n], y[n], first[n], second[n], third[n];
fill(first, first + n, -1);
fill(second, second + n, -1);
fill(third, third + n, -1);
unordered_map<long long, int> H;
vector<pair<pair<int, int>, int> > v, u;
for (i = 0; i < n; i++) {
scanf("%d %d", &x[i], &y[i]);
H[func(x[i], y[i])] = 1;
v.push_back(make_pair(make_pair(x[i], y[i]), i));
u.push_back(make_pair(make_pair(y[i], x[i]), i));
}
sort(v.begin(), v.end());
sort(u.begin(), u.end());
for (i = 0; i < v.size(); i++) {
X = v[i].first.first;
Y = v[i].first.second;
diag[X - Y + 100050].push_back(v[i]);
xaxis[Y + 100050].push_back(v[i]);
}
for (i = 0; i < u.size(); i++) {
X = u[i].first.second;
Y = u[i].first.first;
yaxis[X + 100050].push_back(u[i]);
}
for (i = 0; i < 200099; i++) {
for (j = diag[i].size() - 1; j >= 0; j--) {
first[diag[i][j].second] = j;
}
for (j = xaxis[i].size() - 1; j >= 0; j--) {
second[xaxis[i][j].second] = j;
}
for (j = yaxis[i].size() - 1; j >= 0; j--) {
third[yaxis[i][j].second] = j;
}
}
int val, x1, y1, cnt = 0;
for (i = 0; i < n; i++) {
if (first[i] < second[i] && first[i] < third[i]) {
val = x[i] - y[i] + 100050;
for (j = 0; j < first[i]; j++) {
x1 = diag[val][j].first.first;
y1 = diag[val][j].first.second;
if (H[func(x1, y[i])]) {
if (H[func(x[i], y1)]) cnt++;
}
}
} else if (second[i] < third[i]) {
val = y[i] + 100050;
for (j = 0; j < second[i]; j++) {
x1 = xaxis[val][j].first.first;
y1 = y[i] + x1 - x[i];
if (H[func(x[i], y1)]) {
if (H[func(x1, y1)]) cnt++;
}
}
} else {
val = x[i] + 100050;
for (j = 0; j < third[i]; j++) {
y1 = yaxis[val][j].first.first;
x1 = x[i] + y1 - y[i];
if (H[func(x1, y[i])]) {
if (H[func(x1, y1)]) cnt++;
}
}
}
}
cout << cnt;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
int a[k], i;
for (i = 0; i < k; i++) cin >> a[i];
sort(a, a + k);
int res = a[k - 1] - 25;
if (res < 0) res = 0;
cout << res << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1010][1010] = {0};
int main() {
int m, n, k, j, i;
cin >> m >> n >> k;
int t, d = 0;
for (t = 1; t <= k; t++) {
cin >> i >> j;
a[i][j] = 1;
if ((i + 1 <= m) && (j + 1 <= n)) {
if (a[i + 1][j + 1] && a[i][j + 1] == 1 && a[i + 1][j] == 1) {
cout << t;
d = 1;
break;
}
}
if ((i - 1 > 0) && (j + 1 <= n)) {
if (a[i - 1][j + 1] && a[i][j + 1] == 1 && a[i - 1][j] == 1) {
cout << t;
d = 1;
break;
}
}
if ((i - 1 > 0) && (j - 1 > 0)) {
if (a[i - 1][j - 1] && a[i][j - 1] == 1 && a[i - 1][j] == 1) {
cout << t;
d = 1;
break;
}
}
if ((i + 1 <= m) && (j - 1 > 0)) {
if (a[i + 1][j - 1] && a[i][j - 1] == 1 && a[i + 1][j] == 1) {
cout << t;
d = 1;
break;
}
}
}
if (d == 0) {
cout << 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> seen;
vector<bool> vertex;
inline bool cycle (const vector<vector<int>>& g, int v) {
seen[v] = true;
vertex[v] = true;
bool flag = false;
for (auto u : g[v]) {
if (seen[u]) return true;
if (vertex[u]) continue;
if (cycle(g, u)) flag = true;
}
seen[v] = false;
return flag;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
seen.resize(n); vertex.assign(n, false);
vector<vector<int>> g(n);
for (int i = 0; i < m; i++) {
int s, t;
scanf("%d%d", &s, &t);
g[s].emplace_back(t);
}
bool ans = false;
for (int s = 0; s < n; s++) if (!vertex[s]) {
fill(seen.begin(), seen.end(), false);
if (cycle(g, s)) { ans = true; break; }
}
cout << ans << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct _ {
_() { ios_base::sync_with_stdio(0); }
} _;
template <class A, class B>
ostream &operator<<(ostream &o, pair<A, B> t) {
o << "(" << t.first << ", " << t.second << ")";
return o;
}
template <class T>
string tostring(T first, int len = 0, char c = '0') {
stringstream ss;
ss << first;
string r = ss.str();
if (r.length() < len) r = string(len - r.length(), c) + r;
return r;
}
template <class T>
void PV(T a, T b, int n = 0, int w = 0, string s = " ") {
int c = 0;
while (a != b) {
cout << tostring(*a++, w, ' ');
if (a != b && (n == 0 || ++c % n))
cout << s;
else
cout << "\n";
cout.flush();
}
}
template <class T>
inline bool chmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool chmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
const long long linf = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = int(1e9) + 7;
const int N = 111111;
int n;
vector<int> g[N];
int key[N];
int maxv[N];
int minv[N];
int lmax[N];
int rmin[N];
int depth[N];
int father[N];
void dfs(int u, int par = -1) {
father[u] = par;
maxv[u] = key[u];
minv[u] = key[u];
if (par == -1)
depth[u] = 0;
else
depth[u] = depth[par] + 1;
if (g[u].size() == 0) return;
for (int v : g[u]) {
dfs(v, u);
chmax(maxv[u], maxv[v]);
chmin(minv[u], minv[v]);
}
lmax[u] = maxv[g[u][0]];
rmin[u] = minv[g[u][1]];
}
int p[N][21];
void lca_init() {
memset(p, -1, sizeof(p));
;
for (int i = 0; i < n; i++) p[i][0] = father[i];
for (int j = 1; 1 << j < n; j++)
for (int i = 0; i < n; i++)
if (p[i][j - 1] != -1) p[i][j] = p[p[i][j - 1]][j - 1];
}
int lca_up(int u, int m) {
for (int i = 0; i <= 20; i++)
if (m & (1 << i)) u = p[u][i];
return u;
}
int lca(int a, int b) {
if (depth[a] < depth[b]) swap(a, b);
a = lca_up(a, depth[a] - depth[b]);
if (a == b) return a;
for (int i = 20; i >= 0; i--)
if (p[a][i] != p[b][i]) a = p[a][i], b = p[b][i];
return father[a];
}
double expect[N];
void dfs2(int u, double tot) {
if (g[u].size() == 0) {
expect[u] = tot / depth[u];
return;
}
dfs2(g[u][0], tot + rmin[u]);
dfs2(g[u][1], tot + lmax[u]);
}
int main() {
cin >> n;
int root = 0;
for (int i = 0; i < n; i++) {
int u, v;
cin >> u >> v;
if (u == -1) {
root = i;
} else {
g[u - 1].push_back(i);
}
key[i] = v;
}
for (int i = 0; i < n; i++) {
if (g[i].empty()) continue;
if (key[g[i][0]] > key[g[i][1]]) swap(g[i][0], g[i][1]);
}
for (int i = 0; i < n; i++) lmax[i] = -inf, rmin[i] = inf;
dfs(root);
vector<pair<int, int> > leaf;
for (int i = 0; i < n; i++)
if (g[i].size() == 0) leaf.push_back(make_pair(key[i], i));
sort((leaf).begin(), (leaf).end());
lca_init();
vector<pair<int, int> > interval;
for (int i = 0; i < leaf.size(); i++) {
if (i == 0) {
interval.push_back(
make_pair(-inf, key[lca(leaf[i].second, leaf[i + 1].second)] - 1));
} else if (i + 1 == leaf.size()) {
interval.push_back(
make_pair(key[lca(leaf[i - 1].second, leaf[i].second)] + 1, inf));
} else {
interval.push_back(
make_pair(key[lca(leaf[i - 1].second, leaf[i].second)] + 1,
key[lca(leaf[i].second, leaf[i + 1].second)] - 1));
}
}
dfs2(root, 0);
vector<double> res;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int first;
cin >> first;
int id =
lower_bound((interval).begin(), (interval).end(), make_pair(first, 0)) -
interval.begin();
if (id == interval.size() || first < interval[id].first) id--;
res.push_back(expect[leaf[id].second]);
}
for (double i : res) cout << fixed << setprecision(12) << i << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5, M = 100000 + 5;
int n, m;
int f[N];
struct EdgeTable {
int hd[N], to[M], nxt[M];
inline void addedge(int idx, int a, int b) {
nxt[idx] = hd[a];
hd[a] = idx;
to[idx] = b;
}
};
EdgeTable zheng, fan;
bool can1[N], can2[N];
inline void calc_can1() {
queue<int> q;
for (int i = 1; i <= n; ++i) {
if (f[i] == 1) {
can1[i] = true;
q.push(i);
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int e = zheng.hd[u]; e; e = zheng.nxt[e]) {
int v = zheng.to[e];
if (can1[v]) continue;
can1[v] = true;
q.push(v);
}
}
}
inline void calc_can2() {
queue<int> q;
for (int i = 1; i <= n; ++i) {
if (f[i] == 2) {
can2[i] = true;
q.push(i);
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int e = fan.hd[u]; e; e = fan.nxt[e]) {
int v = fan.to[e];
if (can2[v]) continue;
can2[v] = true;
if (f[v] != 1) q.push(v);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &f[i]);
for (int i = 1; i <= m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
zheng.addedge(i, a, b);
fan.addedge(i, b, a);
}
calc_can1();
calc_can2();
for (int i = 1; i <= n; ++i) printf("%d\n", can1[i] && can2[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 7010;
const int MAXN = 5010;
int n, m, i, j;
bool vis[2][MAXM];
int dis[MAXM];
int st[MAXM], ed[MAXM], ans[MAXM];
void init() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &st[i], &ed[i]);
}
}
void dfs1(int u) {
if (vis[1][u]) return;
vis[1][u] = true;
for (int i = 0; i < m; ++i)
if (st[i] == u) dfs1(ed[i]);
}
void dfs0(int u) {
if (vis[0][u]) return;
vis[0][u] = true;
for (int i = 0; i < m; ++i)
if (ed[i] == u) dfs0(st[i]);
}
int main() {
init();
dfs1(1);
dfs0(n);
bool flag = false;
for (int i = 1; i <= n; ++i) {
flag = false;
for (int j = 0; j < m; ++j) {
if (vis[1][st[j]] && vis[0][ed[j]]) {
if (dis[st[j]] > dis[ed[j]] - 1) {
dis[st[j]] = dis[ed[j]] - 1;
flag = true;
}
if (dis[ed[j]] > dis[st[j]] + 2) {
dis[ed[j]] = dis[st[j]] + 2;
flag = true;
}
}
}
if (flag && i == n) {
printf("No\n");
return 0;
}
}
printf("Yes\n");
for (int i = 0; i < m; ++i) {
if (vis[1][st[i]] && vis[0][ed[i]]) {
printf("%d\n", dis[ed[i]] - dis[st[i]]);
} else
printf("1\n");
}
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.