solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int maxn = 200;
const int inf = 0x3f3f3f3f;
const int INF = 0x7f7f7f7f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long pow_(long long x, long long y) {
long long rt = 1;
while (y) {
if (y & 1) rt = rt * x % mod;
x = x * x % mod;
y >>= 1;
}
return rt;
}
long long dp[maxn][maxn][maxn], n, m, len[maxn];
string s1;
void init() {
len[0] = 2;
len[1] = 2;
for (int i = 2; i < m + 1; i++) len[i] = len[i - 1] * len[i - 2] % mod;
}
int main() {
cin >> n >> m;
init();
cin >> s1;
for (int i = 1; i < n + 1; i++) {
dp[s1[i - 1] - '0'][i][i] = 1;
}
for (int i = 2; i < m + 1; i++) {
for (int l = 1; l < n + 1; l++) {
for (int r = l; r < n + 1; r++) {
if (r == n)
(dp[i][l][r] += dp[i - 1][l][r] * len[i - 2] % mod) %= mod;
else
(dp[i][l][r] += dp[i - 1][l][r]) %= mod;
if (l == 1)
(dp[i][l][r] += dp[i - 2][l][r] * len[i - 1]) %= mod;
else
(dp[i][l][r] += dp[i - 2][l][r]) %= mod;
for (int k = l; k < r; k++) {
(dp[i][l][r] += dp[i - 1][l][k] * dp[i - 2][k + 1][r]) %= mod;
}
}
}
}
cout << dp[m][1][n] << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
struct Point {
long long x, y;
long double atg;
Point() {}
Point(long long x, long long y) : x(x), y(y) {}
long double abs() const { return hypot(x, y); }
long double arg() const { return atan2(y, x); }
Point operator*(double o) const { return Point(x * o, y * o); }
Point operator+(const Point& o) const { return Point(x + o.x, y + o.y); }
Point operator-(const Point& o) const { return Point(x - o.x, y - o.y); }
Point operator/(double o) const { return Point(x / o, y / o); }
bool operator<(const Point& o) const {
return x < o.x - 1e-9 || (x < o.x + 1e-9 && y < o.y - 1e-9);
}
friend bool operator==(const Point& r1, const Point& r2) {
return r1.x == r2.x && r1.y == r2.y;
}
long long cross(Point b) const { return x * b.y - b.x * y; }
void readin() { scanf("%lld%lld", &x, &y); }
} p[2105];
vector<Point> vp;
bool cmp(Point& a, Point& b) { return a.atg < b.atg; }
long long ans;
long long g2(long long x) { return x * (x - 1) / 2; }
void cal() {
int N = vp.size();
for (int i = 0, j = 0; i < N; i++) {
j = max(j, i + 1);
while (vp[i].cross(vp[j % N]) > 0) {
j++;
assert(j < N + N + 5);
}
int cc = j - 1 - i;
ans += g2(cc) * g2(n - 2 - cc);
}
}
void fmain(int ID) {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
p[i].readin();
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
vp.clear();
for (int(j) = 1; (j) <= (int)(n); (j)++)
if (j != i) {
Point px = p[j] - p[i];
px.atg = px.arg();
vp.push_back(px);
}
sort(vp.begin(), vp.end(), cmp);
cal();
}
printf("%lld\n", ans / 2);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0;
string s;
cin >> n;
cin.ignore();
for (int i = 1; i <= n; i++) {
getline(cin, s);
if (s[1] == '+') {
x++;
continue;
}
if (s[1] == '-') {
x--;
continue;
}
}
cout << x;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int nf, ne, nz, rf, re, rz, df, de;
double f, e, z, ans, d[30][30];
int a[100], N;
vector<pair<double, double> > ve;
void dp() {
int i, j, k;
ve.clear();
ve.push_back(make_pair(-1e8, 1e8));
for (i = 0; i <= N; i++) {
for (j = 0; j < a[i]; j++) {
ve.push_back(make_pair(i - z, i + z));
}
}
memset(d, 0, sizeof(d));
d[0][0] = 0;
double fire, elec, l, r;
for (i = 0; i <= N; i++) {
for (j = 0; j < 2 - a[i]; j++) {
fire = 0;
elec = 0;
for (k = 0; k < ve.size(); k++) {
l = max(ve[k].first, i - f);
r = min(ve[k].second, i + f);
if (r > l) {
fire += (r - l);
}
l = max(ve[k].first, i - e);
r = min(ve[k].second, i + e);
if (r > l) {
elec += (r - l);
}
}
fire *= df;
elec *= de;
for (int ii = nf; ii >= 0; ii--) {
for (int jj = ne; jj >= 0; jj--) {
if (ii > 0) {
d[ii][jj] = max(d[ii][jj], d[ii - 1][jj] + fire);
}
if (jj > 0) {
d[ii][jj] = max(d[ii][jj], d[ii][jj - 1] + elec);
}
}
}
}
}
ans = max(ans, d[nf][ne]);
}
int dfs(int pos, int x) {
if (pos == N) {
if (x == 0) {
dp();
}
return 0;
}
if (x < 0) {
return 0;
}
a[pos] = 0;
dfs(pos + 1, x);
a[pos] = 1;
dfs(pos + 1, x - 1);
a[pos] = 2;
dfs(pos + 1, x - 2);
return 0;
}
int main() {
int i, j, k, n, m;
scanf("%d%d%d", &nf, &ne, &nz);
scanf("%d%d%d", &rf, &re, &rz);
scanf("%d%d", &df, &de);
memset(a, 0, sizeof(a));
ans = 0;
f = sqrt(rf * rf - 1);
e = sqrt(re * re - 1);
z = sqrt(rz * rz - 1);
N = (nf + ne + nz + 1) / 2;
dfs(0, nz);
printf("%.10lf", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
using namespace std;
int T = 1;
while (T--) {
int N;
scanf("%d", &N);
vector<int> A(3), B(3);
for (auto &it : A) scanf("%d", &it);
for (auto &it : B) scanf("%d", &it);
int minans = max({0, A[0] + B[1] - N, A[1] + B[2] - N, A[2] + B[0] - N});
int maxans = min(A[0], B[1]) + min(A[1], B[2]) + min(A[2], B[0]);
printf("%d %d\n", minans, maxans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
char s[8][8];
bool ck() {
for (int(i) = 1; (i) <= (int)(4); (i)++)
for (int(j) = 1; (j) <= (int)(4); (j)++)
if (s[i][j] == 'x') {
if (s[i - 1][j - 1] == 'x' && s[i + 1][j + 1] == 'x') return 1;
if (s[i - 1][j] == 'x' && s[i + 1][j] == 'x') return 1;
if (s[i][j - 1] == 'x' && s[i][j + 1] == 'x') return 1;
if (s[i - 1][j + 1] == 'x' && s[i + 1][j - 1] == 'x') return 1;
}
return 0;
}
void fmain(int tid) {
for (int(i) = 1; (i) <= (int)(4); (i)++) scanf("%s", s[i] + 1);
for (int(i) = 1; (i) <= (int)(4); (i)++)
for (int(j) = 1; (j) <= (int)(4); (j)++)
if (s[i][j] == '.') {
s[i][j] = 'x';
if (ck()) etp(1);
s[i][j] = '.';
}
etp();
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string z;
cin >> z;
string s;
cin >> s;
map<char, int> m;
for (auto i : z) m[i]++;
map<char, int> m1;
for (auto i : s) m1[i]++;
int ans = INT_MAX;
int a = INT_MAX;
if (m['2'] != 0 || m['5'] != 0) a = (m1['2'] + m1['5']) / (m['2'] + m['5']);
ans = min(ans, a);
int b = INT_MAX;
if (m['6'] != 0 || m['9'] != 0) b = (m1['6'] + m1['9']) / (m['6'] + m['9']);
ans = min(ans, b);
for (auto i : m)
if (i.first != '2' && i.first != '5' && i.first != '6' && i.first != '9')
if (i.second != 0) ans = min(ans, m1[i.first] / i.second);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
if (b <= a) {
cout << "YES" << endl;
} else {
if (a == 2) {
if (b == 3) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else if (a > 3) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void _print(long long int t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long int mod1 = 1e9 + 7;
long long int INF = 1e9 + 5;
long long int mod = 998244353;
void solve(long long int test_case) {
string s;
cin >> s;
long long int n = s.size();
long long int take = n / 2;
string ans, rev;
long long int i = 0, j = n - 1;
while (j >= i && take > 0) {
if (j > i && s[i] == s[j]) {
ans.push_back(s[i]);
rev.push_back(s[i]);
i++;
j--;
take -= 2;
} else if (j - 1 > i && s[i] == s[j - 1]) {
ans.push_back(s[i]);
rev.push_back(s[i]);
j -= 2;
i++;
take -= 2;
} else if (j > i + 1 && s[i + 1] == s[j]) {
ans.push_back(s[j]);
rev.push_back(s[j]);
j--;
i += 2;
take -= 2;
} else if (j - 1 > i + 1 && s[j - 1] == s[i + 1]) {
ans.push_back(s[j - 1]);
rev.push_back(s[j - 1]);
j -= 2;
i += 2;
take -= 2;
} else {
ans.push_back(s[i]);
i++;
take--;
break;
}
}
reverse(rev.begin(), rev.end());
ans += rev;
if (take > 0 || ans.size() < n / 2) {
cout << "IMPOSSIBLE\n";
} else {
cout << ans;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
long long int i = 1ll;
while (t--) {
solve(i);
i++;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int p[N], l[N], e[N];
int x[N], y[N];
vector<int> qry[N];
stack<int> st;
int f[N];
int ans[N];
int s[N];
int find(int x) {
if (f[x] != x) f[x] = find(f[x]);
return f[x];
}
int main() {
int n, q;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i], &l[i]);
e[i] = p[i] + l[i];
f[i] = i;
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x[i], &y[i]);
qry[x[i]].push_back(i);
}
for (int i = n; i >= 1; i--) {
while (!st.empty() && p[st.top()] <= e[i]) {
f[st.top()] = i;
e[i] = max(e[i], e[st.top()]);
st.pop();
}
if (st.empty())
s[i] = 0;
else {
s[i] = s[st.top()] + p[st.top()] - e[i];
}
st.push(i);
for (auto j : qry[i]) {
ans[j] = s[i] - s[find(y[j])];
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int ma = 1e5 + 5;
int a[ma], b[ma];
int main(int argc, char* argv[]) {
if (argc == 2 or argc == 3) freopen(argv[1], "r", stdin);
if (argc == 3) freopen(argv[2], "w", stdout);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
for (int i = 0; i <= n - 1; i++) cin >> a[i];
for (int i = 0; i <= k - 1; i++) cin >> b[i];
sort(b, b + k);
int j = k - 1;
for (int i = 0; i <= n - 1; i++) {
if (a[i] == 0) {
a[i] = b[j];
j--;
}
}
bool f = false;
for (int i = 0; i <= n - 1; i++) {
for (int j = i - 1; j >= 0; j--) {
if (a[i] <= a[j]) {
f = true;
break;
}
}
}
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
if(n%2==0) cout<<(n/2+1)*(n/2+1)<<endl;
else cout<<2*(n/2+1)*(n/2+2)<<endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, q;
set<int> s;
int t[150005];
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> q;
for (int i = 1; i <= n; ++i) cin >> t[i];
int tp, x;
while (q--) {
cin >> tp >> x;
if (tp == 1) {
s.insert(t[x]);
if (s.size() > k) {
s.erase(s.begin());
}
} else {
if (s.find(t[x]) != s.end()) {
cout << "YES\n";
} else
cout << "NO\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct IOS {
struct Input {
int readInt() {
int x;
scanf("%d", &x);
return x;
}
long long readLong() {
long long x;
scanf("%lld", &x);
return x;
}
char readChar() {
char c;
scanf("%c", &c);
return c;
}
double readDouble() {
double x;
scanf("%lf", &x);
return x;
}
string readString() {
char str[100005];
scanf("%s", &str);
return str;
}
void readIntArray(int* arr, int st, int en) {
for (int i = st; i <= en; i++) arr[i] = readInt();
}
} in;
struct Output {
void newLine() { printf("\n"); }
} out;
};
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
std::cout << v << ' ';
return *this;
}
} dbg;
int arr[100005];
int cnt[100005];
int ans[100005];
vector<int> useable;
vector<pair<int, int> > Q;
class BIT {
public:
long long n, tree[100005];
BIT() {}
void Init(int _n) { n = _n; }
void Reset() { memset(tree, 0, sizeof tree); }
void Update(int idx, long long val) {
for (; idx <= n; idx += idx & (-idx)) tree[idx] += val;
}
long long Query(int idx) {
long long res = 0;
for (; idx; idx -= idx & (-idx)) res += tree[idx];
return res;
}
long long Query(int l, int r) { return Query(r) - Query(l - 1); }
};
BIT tree;
int main() {
IOS ios;
int n = ios.in.readInt();
int m = ios.in.readInt();
tree.Init(n);
for (int i = 0; i <= n - 1; i++) {
arr[i] = ios.in.readInt();
if (arr[i] <= n) cnt[arr[i]]++;
}
for (int i = 1; i <= n; i++)
if (cnt[i] >= i) useable.push_back(i);
for (int i = 0; i <= m - 1; i++) {
int l = ios.in.readInt();
int r = ios.in.readInt();
Q.push_back({l, r});
}
for (int i = 0; i < useable.size(); i++) {
tree.Reset();
int val = useable[i];
for (int j = 0; j <= n - 1; j++)
if (arr[j] == val) tree.Update(j + 1, 1);
for (int j = 0; j <= m - 1; j++) {
int l = Q[j].first;
int r = Q[j].second;
ans[j] += (tree.Query(l, r) == val);
}
}
for (int i = 0; i <= m - 1; i++) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(10);
int tt;
cin >> tt;
while (tt--) {
int n, s;
cin >> n >> s;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<double> time1(n);
vector<double> time2(n);
int speed = 1;
for (int i = 0; i < n; i++) {
time1[i] = (double)(a[i] - (i > 0 ? a[i - 1] : 0)) / speed;
speed++;
if (i > 0) {
time1[i] += time1[i - 1];
}
}
speed = 1;
for (int i = n - 1; ~i; i--) {
time2[i] = (double)((i + 1 < n ? a[i + 1] : s) - a[i]) / speed;
speed++;
if (i + 1 < n) {
time2[i] += time2[i + 1];
}
}
int pos = 0;
for (int i = 0; i < n; i++) {
if (abs(time1[i] - time2[i]) < abs(time1[pos] - time2[pos])) {
pos = i;
}
}
double ans = 0;
if (time1[pos] == time2[pos]) {
ans = time1[pos];
} else if (time1[pos] > time2[pos]) {
double dis = a[pos] - (pos > 0 ? a[pos - 1] : 0);
int sp1 = pos + 1;
int sp2 = n - pos + 1;
double newtime1 = (pos > 0 ? time1[pos - 1] : 0);
double newtime2 = time2[pos];
dis -= (newtime2 - newtime1) * sp1;
ans = newtime2 + dis / (sp1 + sp2);
} else {
double dis = (pos + 1 < n ? a[pos + 1] : s) - a[pos];
int sp1 = pos + 2;
int sp2 = n - pos;
double newtime1 = time1[pos];
double newtime2 = (pos + 1 < n ? time2[pos + 1] : 0);
dis -= (newtime1 - newtime2) * sp2;
ans = newtime1 + dis / (sp1 + sp2);
}
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, n, i, j, a, b;
long long ans = 0;
cin >> n >> k >> a >> b;
if (k == 1) {
cout << a * (n - 1);
} else {
while (1) {
if (n % k == 0) {
if (b > (a * (n - (n / k)))) {
ans += a * (n - (n / k));
n = n / k;
} else {
ans += b;
n = n / k;
}
} else {
ans += a * (n % k);
n = n - (n % k);
}
if (n == 0) {
cout << ans - a;
return 0;
}
if (n == 1) {
cout << ans;
return 0;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, l, r, k, Q;
string s, aux;
int main() {
cin >> s;
N = s.length();
aux.resize(11000);
cin >> Q;
int i;
while (Q--) {
cin >> l >> r >> k;
l--, r--;
k %= (r - l + 1);
for (i = l; i <= r; i++) {
if (i + k <= r)
aux[i + k] = s[i];
else
aux[i + k - r + l - 1] = s[i];
}
for (i = l; i <= r; i++) s[i] = aux[i];
}
cout << s << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxi = 1e6 + 6;
int n;
long long a[maxi], b[maxi];
long long k;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
long long len = n;
long long tr = 1;
long long sum = 0;
for (int i = 1; i <= n; i++) {
b[i] = sum - (n - i) * (tr - 1) * a[i];
if (b[i] < k) {
printf("%d\n", i);
len--;
} else {
sum += (tr - 1) * a[i];
tr++;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << "INTERCAL" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
const int N = (int)2e5 + 100;
int cnt[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
int a, b, res = 0;
while (m--) {
cin >> a >> b;
if (a < b) swap(a, b);
cnt[b]++;
if (cnt[b] == 1) res++;
}
int q;
cin >> q;
while (q--) {
int c;
cin >> c;
if (c == 1) {
cin >> a >> b;
if (a < b) swap(a, b);
cnt[b]++;
if (cnt[b] == 1) res++;
} else if (c == 2) {
cin >> a >> b;
if (a > b) swap(a, b);
cnt[a]--;
if (cnt[a] == 0) res--;
} else {
cout << (n - res) << '\n';
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int INF = 213456789;
const int inf = 0x3f3f3f3f;
const double eps = 1e-7;
template <class T>
T gcd(T a, T b) {
if (!b) return a;
return gcd(b, a % b);
}
int n, k;
int main() {
cin >> n >> k;
n--;
int delt = n % k, dep = n / k, ans;
if (delt >= 2)
ans = 2 * dep + 2;
else if (delt == 1)
ans = 2 * dep + 1;
else
ans = 2 * dep;
cout << ans << endl;
for (int i = 0; i < k; i++) cout << 1 << " " << i + 2 << endl;
for (int i = k + 2; i <= n + 1; i++) {
cout << i << " " << i - k << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
void fast() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int main() {
fast();
lli q;
q = 1;
while (q--) {
lli n, bbb, i, j, k, m, p;
cin >> n >> bbb;
bbb = bbb * 8;
bbb = bbb / n;
k = 1;
for (int i = 0; i < bbb; i++) k *= 2;
vector<lli> a(n), b(n), bb(n);
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
j = 0;
b[j] = a[0], bb[j] = 1;
for (i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
j++;
b[j] = a[i];
bb[j] = 1;
} else {
bb[j]++;
}
}
int ma = 0, s = 0;
for (i = 0; i < k; i++) {
s = s + bb[i];
if (i == j) break;
}
ma = s;
for (i = k; i <= j; i++) {
s = s + bb[i] - bb[i - k];
ma = max(ma, s);
}
cout << n - ma << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x, maxx, counter[4];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
counter[x]++;
}
for (int i = 1; i <= 3; i++) {
maxx = max(maxx, counter[i]);
}
n -= maxx;
cout << n << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int f[105][105];
int n, m;
void init() {
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
f[i][j] = j;
}
}
return;
}
int getf(int i, int x) {
if (f[i][x] == x)
return x;
else
return f[i][x] = getf(i, f[i][x]);
}
void merge(int i, int x, int y) {
int t1 = getf(i, x);
int t2 = getf(i, y);
if (t1 != t2) {
f[i][t2] = t1;
return;
}
return;
}
int main() {
int i;
int a, b, c;
while (scanf("%d %d", &n, &m) != EOF) {
init();
for (i = 1; i <= m; i++) {
scanf("%d %d %d", &a, &b, &c);
merge(c, a, b);
}
int t, f;
scanf("%d", &t);
while (t--) {
f = 0;
scanf("%d %d", &a, &b);
for (int j = 1; j <= m; j++) {
if (getf(j, a) == getf(j, b)) {
f++;
}
}
printf("%d\n", f);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int x[maxn], y[maxn];
int n;
long long cross(int x1, int y1, int x2, int y2) {
return (long long)x1 * y2 - (long long)x2 * y1;
}
int main() {
int i, l, r;
scanf("%d", &n);
for (i = 0; i < n; ++i) scanf("%d%d", x + i, y + i);
l = x[0];
r = x[1];
x[n] = x[0];
y[n] = y[0];
if (l > r) swap(l, r);
for (i = 0; i < n; ++i) {
while (l <= r &&
cross(x[i + 1] - x[i], y[i + 1] - y[i], l - x[i], y[0] - y[i]) > 0)
++l;
while (l <= r &&
cross(x[i + 1] - x[i], y[i + 1] - y[i], r - x[i], y[0] - y[i]) > 0)
--r;
}
printf("%d\n", r - l + 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static const long long L = 233333;
static char sxd[L], *sss = sxd, *ttt = sxd;
if (sss == ttt) {
ttt = (sss = sxd) + fread(sxd, 1, L, stdin);
if (sss == ttt) {
return EOF;
}
}
return *sss++;
}
inline char readalpha() {
char c = getchar();
for (; !isalpha(c); c = getchar())
;
return c;
}
inline char readchar() {
char c = getchar();
for (; c == ' '; c = getchar())
;
return c;
}
template <class T>
inline bool read(T& x) {
bool flg = false;
char c = getchar();
x = 0;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
flg = true;
} else if (c == EOF) {
return false;
}
}
for (; isdigit(c); c = getchar()) {
x = (x << 1) + (x << 3) + (c ^ 48);
}
if (flg) {
x = -x;
}
return true;
}
template <class T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10) {
putchar(x | 48);
return;
}
write(x / 10);
putchar((x % 10) | 48);
}
const int maxn = 100005;
int dirx[] = {0, 0, -1, -1, -1, 1, 1, 1};
int diry[] = {1, -1, 0, -1, 1, 0, -1, 1};
int n, m;
map<int, map<int, int> > mp, mp2;
struct Node {
int x, y;
} no[maxn];
bool vis[maxn];
int main() {
read(n), read(m);
queue<int> q;
for (int i = 1; i <= m; ++i) {
read(no[i].x);
read(no[i].y);
mp[no[i].x][no[i].y] = i;
mp2[no[i].y][no[i].x] = i;
if (no[i].x == n || no[i].y == 1) {
q.push(i);
vis[i] = true;
}
}
while (!q.empty()) {
int now = q.front();
q.pop();
if (no[now].x == 1 || no[now].y == n) {
puts("-1");
return 0;
}
for (int i = 0; i < 8; ++i) {
int xx = no[now].x + dirx[i];
int yy = no[now].y + diry[i];
if (mp.count(xx) && mp[xx].count(yy) && !vis[mp[xx][yy]]) {
q.push(mp[xx][yy]);
vis[mp[xx][yy]] = true;
}
}
if (mp.count(no[now].x - 1) && !mp[no[now].x - 1].empty()) {
auto xx = mp[no[now].x - 1].upper_bound(no[now].y + 1);
if (xx != mp[no[now].x - 1].begin() && !vis[(--xx)->second]) {
q.push(xx->second);
vis[xx->second] = true;
}
}
if (mp2.count(no[now].y + 1) && !mp2[no[now].y + 1].empty()) {
auto xx = mp2[no[now].y + 1].lower_bound(no[now].x - 1);
if (xx != mp2[no[now].y + 1].end() && !vis[xx->second]) {
q.push(xx->second);
vis[xx->second] = true;
}
}
}
printf("%d\n", (n - 1) << 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using DO = long double;
using VI = vector<int>;
using pdi = pair<DO, int>;
int first[1010], b[1010];
int pre[1010], n, L;
DO dp[1010], eps = 1e-9;
DO dist[1010][1010];
bool smin(DO &a, DO b) {
if (b > a + eps) return false;
a = b;
return true;
}
bool can(DO t) {
for (int i = 1; i <= n; i++) {
dp[i] = dist[0][i] - b[i] * t, pre[i] = 0;
for (int j = 1; j < i; j++) {
if (smin(dp[i], dp[j] + dist[j][i] - b[i] * t)) {
pre[i] = j;
}
}
}
return dp[n] < -eps;
}
int main() {
scanf("%d %d", &n, &L);
for (int i = 1; i <= n; i++) {
scanf("%d %d", first + i, b + i);
}
for (int j = 1; j <= n; j++) {
for (int i = 0; i < j; i++) {
dist[i][j] = sqrtl(fabsl(first[j] - first[i] - L));
}
}
DO st = 0, ed = dist[0][n] / b[n];
for (int i = 77; i--;) {
DO md = (st + ed) / 2;
if (can(md))
ed = md;
else
st = md;
}
can(ed);
VI ans;
for (int u = n; u; u = pre[u]) ans.push_back(u);
for (int i = ans.size(); i--;) {
printf("%d ", ans[i]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string en = "\n";
string sp = " ";
string t = "hello";
string Y = "YES\n";
string N = "NO\n";
int dx[] = {-1, 0, 0, 1, -1, -1, 1, 1}, Row, Col;
int dy[] = {0, -1, 1, 0, -1, 1, -1, 1};
int kx[] = {-2, -2, 2, 2, -1, -1, 1, 1};
int ky[] = {-1, 1, -1, 1, -2, 2, -2, 2};
using LL = long long;
using LD = long double;
using ULL = unsigned long long;
bool isprm(LL a) {
for (LL i = 2; i * i <= a; i++) {
if (a % i == 0) return false;
}
return true;
}
bool palin(string a) {
for (int i = 0; i < a.size(); i++) {
if (a.at(i) != a.at(a.size() - i - 1)) return 0;
}
return 1;
}
LL binpow(LL a, LL b) {
LL r = 1;
while (b > 0) {
if (b & 1) r = r * a;
a = a * a;
b >>= 1;
}
return r;
}
LL binpow(LL a, LL b, LL m) {
a %= m;
LL r = 1;
while (b > 0) {
if (b & 1) r = r * a % m;
a = a * a % m;
b >>= 1;
}
return r;
}
template <typename T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
LL xgcd(LL a, LL b, LL &x, LL &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
LL x1, y1;
LL d = xgcd(b, a % b, x1, y1);
x = y1, y = x1 - y1 * (a / b);
return d;
}
int main() {
LL i, j, k, n, m, l, s = 0, x, y, tc = 1, p, q, a, b, c = 0, d;
bool f = 0, ff = 0;
string st, sa, sb, sc;
char ch;
while (cin >> a >> b >> c) {
d = xgcd(a, b, x, y);
c *= -1;
if (c % d == 0) {
a = a / d, b = b / d, c = c / d;
d = xgcd(a, b, x, y);
cout << x * c << sp << y * c << en;
} else
cout << -1 << en;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string ans[2] = {"NO", "YES"};
string lex_min(string a) {
if ((a.size()) & 1) return a;
string b, c;
b = lex_min(a.substr(0, a.size() / 2));
c = lex_min(a.substr(a.size() / 2, a.size() / 2));
if (b < c)
return b + c;
else
return c + b;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
string a, b;
cin >> a >> b;
cout << ans[lex_min(a) == lex_min(b)] << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define rep(i, a, b) for (int i = (a); i < (b); ++i)
std::mt19937 rng((int) std::chrono::steady_clock::now().time_since_epoch().count());
using namespace std;
// #define int long long
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
ll mod = (1000000007LL);
inline ll Mod(ll a, ll b){return (a%b);}
inline ll poww(ll a, ll b){ll res = 1;while (b > 0){if(b & 1) res = (res * a)%mod;a = (a * a)%mod;b >>= 1;}return res;}
ll gcd (ll a, ll b) { while (b) { a %= b,swap(a, b);}return a;}
void read(vector<int> &w, int n){w.resize(n);for(int i = 0; i < n; i++) cin>>w[i];}
void print(vector<int> &w){for(int i =0; i < sz(w); i++){if(i == sz(w) - 1) cout<<w[i]<<"\n";else cout<<w[i]<<" ";}}
int prodmod(vector<int> w);
int summod(vector<int> w);
///CUIDADO COM MAXN
#define N 300050
int n, m, q, k, v[N];
ll ans;
vector<int> grafo[N];
vector<pii> caras[N];
// pii w[N];
// string s;
int ini[N], fim[N], cnt, sz[N], bit[N];
struct LCA{
vector<int> nivel, pai;
vector< vector<int> > anc;
const int M = 20; // LOGN
void dfs(int x){
ini[x] = ++cnt;
sz[x] = 1;
for(int i = 0; i<grafo[x].size();i++){
int v = grafo[x][i];
if(nivel[v] == -1){
nivel[v] = nivel[x] + 1;
pai[v] = x;
dfs(v);
sz[x] += sz[v];
}
}
fim[x] = cnt;
}
void init(int n){
nivel.resize(n+1);
pai.resize(n+1);
anc.resize(n+1);
for(int i = 0; i <= n; i++) anc[i].resize(M);
for(int i = 1; i<= n;i++){
pai[i] = nivel[i] = -1;
for(int j = 0; j<M;j++)
anc[i][j] = -1;
}
pai[1] = 1;
nivel[1] = 0;
dfs(1);
for(int i = 1; i<=n; i++) anc[i][0] = pai[i];
for(int j = 1; j<M; j++)
for(int i = 1; i<=n; i++)
anc[i][j] = anc[anc[i][j-1]][j-1];
}
int lca(int u, int v){
if(nivel[v] > nivel[u]) swap(u, v);
for(int i = M - 1; i>=0; i--)
if(nivel[u] - (1<<i) >= nivel[v]) u = anc[u][i];
if(u == v) return u;
for(int i = M - 1; i>=0; i--)
if(anc[u][i] != -1 & anc[u][i] != anc[v][i]){
u = anc[u][i];
v = anc[v][i];
}
return anc[u][0];
}
int ptr = 0;
int find_subtree(int x, int p){
if(x == p) return 0;
int u = x;
for(int j = M - 1; j >= 0; j--){
if(nivel[u] - (1<<j) > nivel[p]) u = anc[u][j];
}
return u;
}
} T;
int dp[N];
void solve(int x, int p){
map<int, int> L,ex;
map<pii, int> LR;
int tot = 0;
for(auto v: grafo[x]){
if(v == p) continue;
solve(v, x);
dp[x]+=dp[v];
}
for(auto w: caras[x]){
int a = T.find_subtree(w.f, x);
int b = T.find_subtree(w.s, x);
if(a > b) swap(a, b);
if(a > 0) dp[a] --;
if(b > 0) dp[b] --;
if(a > 0 and b > 0) ans += tot - L[a] - L[b] + LR[{a, b}];
else if(b > 0) ans +=tot - L[b];
else ans += tot;
L[a] ++, L[b] ++, LR[{a, b}] ++;
tot ++;
}
ans += 1LL*dp[x]*tot;
// cout<<x<<" "<<dp[x]<<" cccc "<<tot<<"\n";
for(auto v: grafo[x]){
if(v == p) continue;
ans -= 1LL*dp[v]*(L[v]);
}
// cout<<"SOLVED "<<x<<" = "<<ans<<"\n";
}
int32_t main(){
ios::sync_with_stdio(false); cin.tie(0);
cin>>n;
for(int i = 1, a, b; i < n; i++){
cin>>a>>b;
grafo[a].pb(b);
grafo[b].pb(a);
}
T.init(n);
cin>>q;
for(int i = 1; i <= q; i++){
int a, b, c;
cin>>a>>b;
c = T.lca(a, b);
caras[c].pb({a, b});
dp[a] ++, dp[b] ++, dp[c] -= 2;
}
solve(1,1);
cout<<ans<<"\n";
}
/*
CUIDADO COM MAXN, MOD, OVERFLOW
>Colocar (>DEFINE INT LONG LONG<) no inicio do template
>mod = (1e9 + 7), por padrao (NAO ESQUECER DE ALTERAR)
>NAO ESQUECER DEFINE INT LONG LONG
> N = 1 ?
*/
int summod(vector<int> w){int curr=0;for(int i=0;i<sz(w); i++){curr = (curr+w[i])%mod;if(curr<0)curr+=mod;}return curr;}
int prodmod(vector<int> w){int curr = 1;
for(int i = 0; i < sz(w); i++){if(w[i] >= mod) w[i] %= mod;curr = (curr * w[i]) % mod;if(curr < 0) curr += mod;}return curr;}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, i, k, x, ans;
string ss;
cin >> t;
while (t--) {
cin >> k >> x;
ans = x + (k - 1) * 9;
cout << ans << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n == 0) {
cout << 1;
return 0;
}
n %= 4;
if (n == 0)
cout << 6;
else if (n == 1)
cout << 8;
else if (n == 2)
cout << 4;
else if (n == 3)
cout << 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, size[1000000];
double sum1, sum2, ans, s[1000000], t[1000000];
int read() {
int x = 0, k = 1;
char c;
c = getchar();
while (c < '0' || c > '9') {
if (c == '-') k = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * k;
}
struct edge {
int cnp, to[1000000], last[1000000], head[1000000];
edge() { cnp = 2; }
void add(int u, int v) {
to[cnp] = v, last[cnp] = head[u], head[u] = cnp++;
to[cnp] = u, last[cnp] = head[v], head[v] = cnp++;
}
} E1;
void dfs(int u, int fa) {
for (int i = E1.head[u]; i; i = E1.last[i]) {
int v = E1.to[i];
if (v == fa) continue;
dfs(v, u);
ans += t[u] * size[v] * s[v];
s[u] += s[v];
size[u] += size[v];
}
size[u] += 1;
ans += t[u] * (1 - s[u]) * (n - size[u]);
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
E1.add(u, v);
}
for (int i = 1; i <= n; i++)
s[i] = read(), t[i] = read(), sum1 += s[i], sum2 += t[i];
for (int i = 1; i <= n; i++) s[i] /= sum1, t[i] /= sum2;
dfs(1, 0);
printf("%.9lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> prime_mods = {
1000000000108174411LL, 1000000000108174427LL, 1000000000108174433LL,
1000010000005470301LL, 1000010000005470329LL, 1000010000005470341LL,
};
int n;
long long mod = 1e9 + 7;
vector<int> w;
int wu(int a, int b) {
int wu = 0;
bitset<12> A(a), B(b);
for (int i = 0; i < n; i++) {
if (A[i] == B[i]) wu += w[i];
}
return wu;
}
vector<int> af() { return {1, 2, 3}; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int mni = n, mnj = m, mxi = 1, mxj = 1;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] == 'B') {
if (i + 1 < mni) mni = i + 1;
if (i + 1 > mxi) mxi = i + 1;
if (j + 1 < mnj) mnj = j + 1;
if (j + 1 > mxj) mxj = j + 1;
}
}
}
cout << (mxi + mni) / 2 << " " << (mxj + mnj) / 2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int b, int c) { return b < c; }
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, cmp);
for (int i = 0; i < n - 1; i++) {
if (a[i + 1] - a[i] <= 1) {
for (int j = i; j < n - 1; j++) {
a[j] = a[j + 1];
}
n--;
i--;
} else if (a[i + 1] - a[i] > 1) {
continue;
}
}
if (n == 1) {
cout << "YES" << endl;
}
if (n > 1) {
cout << "NO" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 3333;
const long long oo = 1e18;
int b[nax], c[nax];
int n, m;
vector<int> g[nax];
pair<long long, long long> dp[nax][nax], nxt[nax];
void calc(int u, int p) {
dp[u][0].first = c[u];
for (int v : g[u]) {
if (v == p) continue;
calc(v, u);
for (int j = 0; j <= m; j++) {
nxt[j] = {-oo, 0};
}
for (int x = 0; x <= m; x++) {
for (int y = 0; y <= m; y++) {
if (dp[u][x].first == -oo || dp[v][y].first == -oo) break;
if (x + y > m) break;
pair<long long, long long> nxx;
nxx.first = dp[u][x].first + dp[v][y].first;
nxx.second = dp[u][x].second + dp[v][y].second;
if (nxx.second > nxt[x + y].second) {
nxt[x + y] = nxx;
} else if (nxx.second == nxt[x + y].second &&
nxx.first > nxt[x + y].first) {
nxt[x + y] = nxx;
}
if (x + y + 1 > m) continue;
nxx.first = dp[u][x].first;
nxx.second = dp[v][y].first > 0;
nxx.second += dp[u][x].second + dp[v][y].second;
if (nxx.second > nxt[x + y + 1].second) {
nxt[x + y + 1] = nxx;
} else if (nxx.second == nxt[x + y + 1].second &&
nxx.first > nxt[x + y + 1].first) {
nxt[x + y + 1] = nxx;
}
}
}
for (int j = 0; j <= m; j++) {
dp[u][j] = nxt[j];
}
}
}
void solve() {
cin >> n >> m;
m--;
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
c[i] = x - b[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) dp[i][j] = {-oo, 0};
g[i].clear();
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
calc(1, 0);
cout << (dp[1][m].first > 0) + dp[1][m].second << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
int t;
cin >> t;
while (t--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double dist(int x0, int y0, int x1, int y1) {
return sqrt(double(x0 - x1) * double(x0 - x1) +
double(y0 - y1) * double(y0 - y1));
}
int main() {
int n, vb, vs, xu, yu, xbus;
double best = 1e20;
cin >> n >> vb >> vs;
vector<int> vv;
for (int i = 0; i < n; i++) {
cin >> xbus;
vv.push_back(xbus);
}
cin >> xu >> yu;
int ans = -1;
for (int i = 1; i < n; i++) {
double tmp = vv[i] / (double)vb + dist(vv[i], 0, xu, yu) / double(vs);
if (tmp - best < 1e-9) {
ans = i + 1;
best = tmp;
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-7;
const int OO = 1e6;
bool sortpair(const pair<int, int> &x, const pair<int, int> &y) {
return x.first != y.first ? x.first < y.first : x.second > y.second;
}
int dcomp(double x, double y) {
return fabs(x - y) <= EPS ? 0 : x > y ? 1 : -1;
}
void smile() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
void printarr(int arr[], int n) {
for (int i = 0; i < n; ++i) cout << arr[i] << " ";
cout << endl;
}
void printset(int n) {
stack<int> myst;
while (n) myst.push(n % 2), n /= 2;
while (!myst.empty()) cout << myst.top(), myst.pop();
cout << endl;
}
long long dp[201][201][201];
int n, x, k;
const long long inf = 1e12;
long long arr[201];
long long solve(long long indx, long long fin, long long limit) {
if (limit == k) return -inf;
if (indx == n) return 0;
long long &ret = dp[indx][fin][limit];
if (ret != -1) return ret;
ret = -inf;
ret = max(ret, solve(indx + 1, fin, limit + 1));
if (fin < x) {
ret = max(ret, arr[indx] + solve(indx + 1, fin + 1, 0));
}
return ret;
}
int main() {
smile();
memset(dp, -1, sizeof(dp));
cin >> n >> k >> x;
for (int i = 0; i < n; ++i) cin >> arr[i];
long long ans = solve(0, 0, 0);
if (ans < 0)
cout << -1 << endl;
else
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
int Threshold;
long long w, h, f;
const int intp = 1e9 + 7;
int power(int a, int b) {
long long s = 1;
for (long long w = a; b; b >>= 1, w = w * w % intp)
if (b & 1) s = s * w % intp;
return s;
}
int top;
long long inver[210000], prime[210000];
bool flag[210000];
void Sieve(int Up) {
int vi, vj;
inver[1] = 1;
for (vi = 2; vi <= Up; vi++) {
if (!flag[vi]) {
prime[++top] = vi;
inver[vi] = power(vi, intp - 2);
}
vj = 1;
while (vi * prime[vj] <= Up) {
inver[vi * prime[vj]] = inver[vi] * inver[prime[vj]] % intp;
flag[vi * prime[vj]] = 1;
if (!(vi % prime[vj])) break;
vj++;
}
}
}
long long C[2][210000];
struct que {
int n, k, num;
long long ans;
} Q[410000];
inline bool Acmp(const que &a, const que &b) {
return a.n / Threshold == b.n / Threshold ? a.k < b.k
: a.n / Threshold < b.n / Threshold;
}
inline bool Bcmp(const que &a, const que &b) { return a.num < b.num; }
void put(int num, int n, int k) {
top++;
Q[top].n = n;
Q[top].k = k;
Q[top].num = num;
}
long long All, Don, Ans;
long long nowans;
int nown, nowk;
void Moarr(int qn, int qk) {
while (nown < qn) {
nown++;
(nowans *= (nown * inver[nown - nowk] % intp)) %= intp;
}
while (nowk < qk) {
nowk++;
(nowans *= (inver[nowk] * (nown - nowk + 1) % intp)) %= intp;
}
while (nowk > qk) {
(nowans *= (nowk * inver[nown - nowk + 1] % intp)) %= intp;
nowk--;
}
while (nown > qn) {
(nowans *= (inver[nown] * (nown - nowk) % intp)) %= intp;
nown--;
}
}
int main() {
int i, j, k, x, y;
scanf("%I64d%I64d%I64d", &f, &w, &h);
if (!w) {
printf("1\n");
return 0;
}
if (!f) {
if (w > h)
printf("1\n");
else
printf("0\n");
return 0;
}
int maxfw = std::max(w, f);
Sieve(maxfw + 5);
C[0][0] = C[1][0] = 1;
for (i = 1; i <= w - 1; i++)
C[0][i] = (((C[0][i - 1] * (w - i) % intp) * inver[i]) % intp);
for (i = 1; i <= f - 1; i++)
C[1][i] = (((C[1][i - 1] * (f - i) % intp) * inver[i]) % intp);
top = 0;
for (i = 2; i <= w + f; i++) {
x = i / 2;
y = i - x;
if (w >= x && f >= y) (All += C[0][x - 1] * C[1][y - 1] % intp) %= intp;
if (w - x * h >= x && f >= y) put(i * 4, w - x * h - 1, x - 1);
std::swap(x, y);
if (w >= x && f >= y) (All += C[0][x - 1] * C[1][y - 1] % intp) %= intp;
if (w - x * h >= x && f >= y) put(i * 4 + 1, w - x * h - 1, x - 1);
}
Threshold = maxfw / ceil(sqrt(top));
if (!Threshold) Threshold = 1;
std::sort(Q + 1, Q + top + 1, Acmp);
nown = 1;
nowk = 1;
nowans = 1;
for (i = 1; i <= top; i++) {
Moarr(Q[i].n, Q[i].k);
Q[i].ans = nowans;
}
for (i = 1; i <= top; i++) {
j = Q[i].num >> 2;
k = Q[i].num & 3;
x = j / 2;
y = j - x;
if (k) std::swap(x, y);
(Don += Q[i].ans * C[1][y - 1] % intp) %= intp;
}
Ans = Don * power(All, intp - 2) % intp;
printf("%I64d\n", Ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
static int x, f;
static char c;
x = 0, f = 1, c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int N = 3005;
int r, c, n, k, px[N], py[N], node[N];
vector<int> pp[N];
long long ans;
int Nxt[N], Lst[N], pos[N], vr[N], L[N], R[N], He, La, cntv;
long long sum;
vector<int> q[N];
inline void upda(int i) {
if (i && L[i] <= R[i] && vr[i] <= c)
sum += (R[i] - L[i] + 1) * (c - vr[i] + 1);
}
inline void decaa(int i) {
if (i && L[i] <= R[i] && vr[i] <= c)
sum -= (R[i] - L[i] + 1) * (c - vr[i] + 1);
}
inline void Del(int x) {
if (x == He) {
int p, t, y = Nxt[x];
if (!y) {
decaa(x);
He = La = sum = 0;
return;
}
decaa(y), L[y] = 1;
if (pos[x] == pos[y]) {
for (p = y, t = 1; t < k; ++t) p = Nxt[p];
vr[y] = p ? pos[p] : (c + 1);
}
upda(y);
decaa(x);
He = y, Nxt[x] = Lst[y] = 0;
return;
}
if (x == La) {
if (!Lst[x]) {
decaa(x);
He = La = sum = 0;
return;
}
int y, t;
for (y = x, t = 1; t < k && y; ++t) {
y = Lst[y];
if (!y) break;
decaa(y), vr[y] = c + 1, upda(y);
}
decaa(x), y = Lst[x], Lst[x] = Nxt[y] = 0, La = y;
return;
}
int y, z, t, p, w;
y = Nxt[x];
decaa(y), L[y] = L[x];
if (pos[x] == pos[y]) {
for (p = y, t = 1; t < k; ++t) p = Nxt[p];
vr[y] = p ? pos[p] : (c + 1);
}
upda(y);
z = vr[x];
for (y = x, t = 1; t < k && y; ++t) {
y = Lst[y];
if (!y) break;
decaa(y);
w = vr[y], vr[y] = z, z = w;
upda(y);
}
decaa(x), y = Lst[x], z = Nxt[x];
Lst[x] = Nxt[x] = 0, Nxt[y] = z, Lst[z] = y;
return;
}
inline void solve(int r) {
int i, j, t, p, id;
cntv = He = La = 0;
sum = 0;
for (i = 1; i <= n; ++i)
node[i] = Nxt[i] = Lst[i] = pos[i] = L[i] = R[i] = vr[i] = 0;
for (i = 1; i <= n; ++i)
if (px[i] <= r) q[py[i]].push_back(i);
for (i = 1; i <= c; ++i)
for (j = 0; j < q[i].size(); ++j) {
id = q[i][j];
if (!He) {
node[id] = He = La = cntv = 1, pos[1] = py[id];
} else {
node[id] = ++cntv;
pos[cntv] = py[id];
Nxt[La] = cntv, Lst[cntv] = La, La = cntv;
}
}
for (i = He, j = 0; i; i = Nxt[i]) {
L[i] = j + 1, R[i] = pos[i], j = pos[i];
for (p = i, t = 1; t < k; ++t) p = Nxt[p];
if (!p)
vr[i] = c + 1;
else
vr[i] = pos[p];
upda(i);
}
for (i = 1; i <= r; ++i) {
ans += sum;
for (j = 0; j < pp[i].size(); ++j) Del(node[pp[i][j]]);
}
for (i = 1; i <= n; ++i) q[py[i]].clear();
}
int main() {
int i, j;
r = read(), c = read(), n = read(), k = read();
for (i = 1; i <= n; ++i)
px[i] = read(), py[i] = read(), pp[px[i]].push_back(i);
for (i = 1; i <= r; ++i) solve(i);
cout << ans << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000010;
int N, M;
int cnt[MAXN], last[MAXN];
long long a[MAXN], sum[MAXN];
int main() {
while (scanf("%d%d", &N, &M) != EOF) {
for (int i = 1; i <= N; i++) {
scanf("%I64d", &a[i]);
a[i + N] = a[i];
}
memset(cnt, 0, sizeof(cnt));
sum[0] = 0;
for (int i = 1; i <= N * 2; i++) sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= N * 2; i++) last[i] = i;
while (M--) {
long long n;
scanf("%I64d", &n);
int j = 1;
for (int i = N + 1; i <= N * 2; i++) {
while (sum[i] - sum[j] > n) j++;
last[i] = last[j];
cnt[i] = cnt[j] + 1;
if (i - last[i] >= N) {
printf("%d\n", cnt[i]);
break;
}
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, i;
cin >> n >> k;
if (n == 1 && k == 1)
cout << "Yes";
else if (n == 1 && k == 2)
cout << "Yes";
else if (k >= n) {
cout << "No";
} else {
for (i = 1; i <= k; i++) {
if (n % i != (i - 1)) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<int> G[100013];
int a[9] = {1, 3, 5, 6, 2, 7, 4, 8, 9};
int* g[3] = {a, a + 3, a + 6};
bool judge(int N, int M) {
for (int i = int(0), __border_righti = int(N); i < __border_righti; i++) {
for (int j = int(0), __border_rightj = int(M - 1); j < __border_rightj;
j++) {
int x1 = (g[i][j] - 1) / M, x2 = (g[i][j + 1] - 1) / M,
y1 = (g[i][j] - 1) % M, y2 = (g[i][j + 1] - 1) % M;
if (x1 == x2 && abs(y1 - y2) == 1) {
return false;
}
if (y1 == y2 && abs(x1 - x2) == 1) {
return false;
}
}
}
for (int i = int(0), __border_righti = int(N - 1); i < __border_righti; i++) {
for (int j = int(0), __border_rightj = int(M); j < __border_rightj; j++) {
int x1 = (g[i][j] - 1) / M, x2 = (g[i + 1][j] - 1) / M,
y1 = (g[i][j] - 1) % M, y2 = (g[i + 1][j] - 1) % M;
if (x1 == x2 && abs(y1 - y2) == 1) {
return false;
}
if (y1 == y2 && abs(x1 - x2) == 1) {
return false;
}
}
}
cout << "A";
return true;
}
void dfs(int k, int N, int M) {
if (k == N * M - 1) {
if (judge(N, M)) {
for (int i = int(0), __border_righti = int(N); i < __border_righti; i++) {
for (int j = int(0), __border_rightj = int(M); j < __border_rightj;
j++) {
printf("%d%c", g[i][j], " \n"[j == M - 1]);
}
}
}
return;
}
for (int i = int(k), __border_righti = int(N * M); i < __border_righti; i++) {
swap(a[i], a[k]);
dfs(k + 1, N, M);
swap(a[i], a[k]);
}
}
void chk(int N, int M) {
int k = 1;
for (int i = int(0), __border_righti = int(N * M); i < __border_righti; i++) {
a[i] = k++;
}
dfs(0, N, M);
}
int main() {
scanf("%d%d", &N, &M);
if (N <= 3 && M <= 3) {
if (N == 1 && M == 1) {
printf("YES\n1\n");
return 0;
} else if (N == 3 && M == 3) {
printf("YES\n1 3 4\n5 7 6\n9 2 8\n");
} else {
printf("NO\n");
}
} else if (N == 1) {
printf("YES\n");
int k = (M & 1) ? M : M - 1;
for (int i = k; i >= 1; i -= 2) {
printf("%d ", i);
}
for (int i = (M & 1) ? M - 1 : M; i >= 2; i -= 2) {
printf("%d%c", i, " \n"[i == 2]);
}
} else if (M == 1) {
printf("YES\n");
int k = (N & 1) ? N : N - 1;
for (int i = k; i >= 1; i -= 2) {
printf("%d\n", i);
}
for (int i = (N & 1) ? N - 1 : N; i >= 2; i -= 2) {
printf("%d\n", i);
}
} else {
int k = 1;
for (int i = int(0), __border_righti = int(N); i < __border_righti; i++) {
for (int j = int(0), __border_rightj = int(M); j < __border_rightj; j++) {
G[i].push_back(k++);
}
}
if (N >= 4) {
for (int j = 1; j < M; j += 2) {
int a = G[0][j], b = G[1][j];
for (int k = int(0), __border_rightk = int(N - 2); k < __border_rightk;
k++) {
G[k][j] = G[k + 2][j];
}
G[N - 2][j] = a;
G[N - 1][j] = b;
}
for (int i = 1; i < N; i += 2) {
int a = G[i][0];
for (int k = int(0), __border_rightk = int(M - 1); k < __border_rightk;
k++) {
G[i][k] = G[i][k + 1];
}
G[i][M - 1] = a;
}
} else if (M >= 4) {
for (int i = 1; i < N; i += 2) {
int a = G[i][0], b = G[i][1];
for (int k = int(0), __border_rightk = int(M - 2); k < __border_rightk;
k++) {
G[i][k] = G[i][k + 2];
}
G[i][M - 2] = a;
G[i][M - 1] = b;
}
for (int j = 1; j < M; j += 2) {
int a = G[0][j];
for (int k = int(0), __border_rightk = int(N - 1); k < __border_rightk;
k++) {
G[k][j] = G[k + 1][j];
}
G[N - 1][j] = a;
}
}
printf("YES\n");
for (int i = int(0), __border_righti = int(N); i < __border_righti; i++) {
for (int j = int(0), __border_rightj = int(M); j < __border_rightj; j++) {
printf("%d%c", G[i][j], " \n"[j == M - 1]);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int aa[500005];
int main() {
int n;
cin >> n;
long long sum = 0;
long long maxn = -1e10;
long long minn = 1e10;
int fu = 0;
int zheng = 0;
for (int i = 1; i <= n; i++) {
cin >> aa[i];
if (aa[i] < 0) {
sum += (-1) * aa[i];
fu = 1;
} else {
sum += aa[i];
zheng = 1;
}
if (aa[i] > maxn) maxn = aa[i];
if (aa[i] < minn) minn = aa[i];
}
if (fu == 0) {
sum -= 2 * minn;
} else if (zheng == 0) {
sum += 2 * maxn;
}
if (n == 1)
cout << aa[1];
else
cout << sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[m], b[m], r[m];
int num;
for (int i = 0; i < m; i++) {
a[i] = 0;
b[i] = 0;
r[i] = 0;
}
for (int i = 0; i < n; i++) {
cin >> num;
a[num]++;
}
for (int i = 0; i < n; i++) {
cin >> num;
b[m - num - 1]++;
}
int i;
stack<int> s;
for (int index = 0; index < 2 * m; index++) {
i = index % m;
for (int j = 0; j < a[i]; j++) s.push(i);
a[i] = 0;
while (b[i] != 0 && s.size() != 0) {
int result = (s.top() + m - i - 1) % m;
r[result]++;
b[i]--;
s.pop();
}
}
for (i = m - 1; i >= 0; i--) {
for (int j = 0; j < r[i]; j++) cout << i << ' ';
}
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, tmp;
cin >> n;
multiset<int> a;
for (int i = 0; i < n; i++) {
cin >> tmp;
a.insert(tmp);
}
int ans = 0;
while (!a.empty()) {
int h = 0;
while (a.lower_bound(h) != a.end()) {
a.erase(a.lower_bound(h));
h++;
}
if (h) ans++;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
char a[1010], b[1010];
int get1() {
int ans = 0, i = 0, j = 0;
while (i < n && j < n) {
while (a[i] <= b[j] && i < n && j < n) i++, j++;
if (i < n && j < n) j++, ans++;
}
return ans;
}
int get2() {
int ans = 0, i = 0, j = 0;
while (i < n && j < n) {
while (a[i] < b[j] && i < n && j < n) ans++, i++, j++;
if (i < n && j < n) j++;
}
return ans;
}
int main() {
cin >> n >> a >> b;
sort(a, a + n);
sort(b, b + n);
cout << get1() << endl;
cout << get2() << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 998244353;
const int maxn = 1010;
const int mn = 64;
void upd(long long &first, long long v) { first = (first + v) % Mod; }
struct mat {
int n, m;
long long a[mn][mn];
void clear() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = 0;
}
}
}
void init() {
clear();
for (int i = 0; i < mn; i++) {
a[i][i] = 1;
}
}
mat operator*(const mat &b) const {
mat c;
c.n = n;
c.m = b.m;
c.clear();
for (int i = 0; i < n; i++) {
for (int j = 0; j < b.m; j++) {
for (int k = 0; k < m; k++) {
upd(c.a[i][j], a[i][k] * b.a[k][j]);
}
}
}
return c;
}
} p[35], c[4];
int n, m, a[maxn], tmp[4];
long long f[maxn][4], g[maxn][4];
bool can[4][4], used[4];
vector<pair<int, int> > v[maxn];
int ti;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
v[i].push_back(make_pair(a[i] + 1, 0));
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int first, second, z;
scanf("%d%d%d", &first, &second, &z);
v[first].push_back(make_pair(second, z));
}
for (int i = 1; i <= n; i++) {
sort(v[i].begin(), v[i].end());
}
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
int first;
scanf("%d", &first);
if (first) {
can[i][j] = true;
}
}
}
for (int i = 0; i < 30; i++) {
p[i].n = p[i].m = mn;
}
for (int i = 0; i < 4; i++) {
c[i].n = c[i].m = mn;
}
for (int mask = 0; mask < mn; mask++) {
for (int i = 0; i < 3; i++) {
tmp[i + 1] = (mask >> (i << 1)) & 3;
}
for (int i = 1; i <= 3; i++) {
memset(used, 0, sizeof(used));
for (int j = 1; j <= 3; j++) {
if (can[i][j]) {
used[tmp[j]] = true;
}
}
int sg;
for (int j = 0; j < 4; j++) {
if (!used[j]) {
sg = j;
break;
}
}
int nxt = sg + (tmp[1] << 2) + (tmp[2] << 4);
upd(p[0].a[nxt][mask], 1);
upd(c[i].a[nxt][mask], 1);
}
}
for (int i = 1; i < 30; i++) {
p[i] = p[i - 1] * p[i - 1];
}
for (int i = 1; i <= n; i++) {
int lst = 0;
mat now;
now.n = mn;
now.m = 1;
now.clear();
now.a[63][0] = 1;
for (int j = 0; j < v[i].size(); j++) {
int second = v[i][j].first - lst - 1;
for (int k = 0; k < 30; k++) {
if (second & (1 << k)) {
now = p[k] * now;
}
}
if (v[i][j].first != a[i] + 1) {
now = c[v[i][j].second] * now;
}
lst = v[i][j].first;
}
for (int j = 0; j < mn; j++) {
upd(g[i][j & 3], now.a[j][0]);
}
}
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
upd(f[i][j ^ k], f[i - 1][j] * g[i][k]);
}
}
}
cout << f[n][0] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int maxn = 2e5 + 5;
constexpr int mod = 998244353;
ll n, k;
ll fac[maxn], facinv[maxn] = {1};
ll qpow(ll a, ll b) {
ll ret = 1;
a %= mod;
while (b > 0) {
if (b & 1) ret = (ret * a) % mod;
b /= 2;
a = (a * a) % mod;
}
return ret;
}
inline void init() {
fac[1] = 1;
for (int i = 2; i <= n; ++i) fac[i] = fac[i - 1] * i % mod;
facinv[n] = qpow(fac[n], mod - 2);
for (int i = n - 1; i >= 1; --i) facinv[i] = facinv[i + 1] * (i + 1) % mod;
}
inline ll C(ll n, ll k) {
return fac[n] * facinv[k] % mod * facinv[n - k] % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k;
init();
ll c = n - k;
if (c <= 0) {
cout << "0\n";
return 0;
}
ll ans = 0;
for (int i = 0; i <= c; ++i) {
ll ret = C(c, i) * qpow(c - i, n) % mod;
if (i & 1)
ans -= ret;
else
ans += ret;
ans = (ans + mod) % mod;
}
ans = ans * C(n, c) % mod;
cout << (k ? ans * 2 % mod : ans) << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n, i, count, k = 0;
scanf("%d", &n);
int a[105];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
char ch = getchar();
for (i = 0; i < n; i++) {
count = 0;
while ((ch = getchar()) != '\n')
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u' ||
ch == 'y')
count++;
if (count == a[i]) k++;
}
if (k == n)
printf("YES");
else
printf("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, sum(0);
vector<pair<int, int> > y[200011];
int cy = 0, ccy;
bool flag;
int main() {
scanf("%d", &n);
for (int i = 1, k, a, X, Y, m; i <= n; ++i) {
scanf("%d%d%d%d%d", &k, &a, &X, &Y, &m);
sum += k;
ccy = 1;
y[ccy].push_back(pair<int, int>(a, i));
for (int j = 1; j < k; ++j) {
a = ((long long)a * (long long)X + (long long)Y) % m;
if (a < y[ccy].back().first) ++ccy;
y[ccy].push_back(pair<int, int>(a, i));
}
cy = max(cy, ccy);
}
printf("%d\n", cy - 1);
if (sum <= 200000)
for (int i = 1; i <= cy; ++i) {
sort(y[i].begin(), y[i].end());
for (unsigned int j = 0; j < y[i].size(); ++j)
printf("%d %d\n", y[i][j].first, y[i][j].second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, ans = 0;
vector<pair<int, int> > snm;
int mod(int a) { return ((a % 1000000007) + 1000000007) % 1000000007; }
int get(int q) {
if (snm[q].first != q) {
int was = snm[q].first;
snm[q].first = get(snm[q].first);
snm[q].second = mod(snm[was].second + snm[q].second);
}
return snm[q].first;
}
int main() {
scanf("%d", &n);
snm.resize(n);
for (int i = 0; i < n; i++) {
snm[i] = make_pair(i, 0);
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int v, x;
scanf("%d%d", &v, &x);
get(--v);
x = mod(x + snm[v].second);
snm[snm[v].first] = make_pair(i, x);
ans = mod(ans + x);
}
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9) + 123;
inline void boost() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int main() {
boost();
cout << "Red";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int num[5005], cnt[5005] = {}, id[5005];
int dp[5005][5005];
bool used[5005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> num[i];
sort(num + 1, num + n + 1);
for (int i = 1; i <= n; i++) {
int r = i;
while (r + 1 <= n && (num[r + 1] - num[i]) <= 5) r++;
cnt[i] = r;
}
for (int j = 1; j <= k; j++) {
for (int i = n; i >= 1; i--) {
dp[i][j] = dp[i + 1][j];
dp[i][j] = max(dp[i][j], dp[cnt[i] + 1][j - 1] + cnt[i] - i + 1);
}
}
cout << dp[1][k] << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
template <class T>
using PQ = priority_queue<T, vector<T>, greater<T>>;
const long long oo = 1e9;
const long long OO = 1e18;
const double eps = 1e-9;
const long long p197 = 1000000007;
const long long p998 = 998244353;
const long long p103 = 1000003;
void solve(long long test_case);
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T = 1;
if (1) cin >> T;
for (long long t = 1; t <= T; t++) solve(t);
return 0;
}
long long n, m;
vector<string> color, dir;
vector<long long> dx, dy;
vector<vector<pair<long long, long long>>> caca;
vector<vector<long long>> distEnd;
vector<vector<long long>> tailleCycle;
void calcEnd(long long i, long long j) {
if (caca[i][j].first != -1) return;
distEnd[i][j] = 0;
caca[i][j] = {i, j};
calcEnd(i + dx[dir[i][j]], j + dy[dir[i][j]]);
if (caca[i + dx[dir[i][j]]][j + dy[dir[i][j]]].first != i ||
caca[i + dx[dir[i][j]]][j + dy[dir[i][j]]].second != j) {
caca[i][j] = caca[i + dx[dir[i][j]]][j + dy[dir[i][j]]];
distEnd[i][j] = 1 + distEnd[i + dx[dir[i][j]]][j + dy[dir[i][j]]];
}
}
void solve(long long test_case) {
cin >> n >> m;
dx.resize(200), dy.resize(200);
dx['R'] = dx['L'] = dy['U'] = dy['D'] = 0;
dx['U'] = dy['L'] = -1;
dx['D'] = dy['R'] = 1;
color.resize(n);
dir.resize(n);
for (long long i = 0; i < (n); ++i) cin >> color[i];
for (long long i = 0; i < (n); ++i) cin >> dir[i];
caca.assign(n, vector<pair<long long, long long>>(m, {-1, -1}));
distEnd.assign(n, vector<long long>(m, -1));
for (long long i = 0; i < (n); ++i)
for (long long j = 0; j < (m); ++j) calcEnd(i, j);
tailleCycle.assign(n, vector<long long>(m, -1));
for (long long i = 0; i < (n); ++i)
for (long long j = 0; j < (m); ++j) {
if (i != caca[i][j].first || j != caca[i][j].second) continue;
long long first = caca[i][j].first, second = caca[i][j].second;
long long L = 1;
long long DX = dx[dir[first][second]], DY = dy[dir[first][second]];
first += DX, second += DY;
while (first != caca[i][j].first || second != caca[i][j].second) {
L++;
DX = dx[dir[first][second]], DY = dy[dir[first][second]];
first += DX, second += DY;
}
tailleCycle[i][j] = tailleCycle[first][second] = L;
}
vector<vector<vector<bool>>> vu;
vu.assign(n, vector<vector<bool>>(m, vector<bool>()));
for (long long i = 0; i < (n); ++i)
for (long long j = 0; j < (m); ++j) {
if ((long long)(vu[caca[i][j].first][caca[i][j].second].size()) == 0)
vu[caca[i][j].first][caca[i][j].second].assign(
tailleCycle[caca[i][j].first][caca[i][j].second], false);
}
long long MAXI = 0;
for (long long i = 0; i < (n); ++i)
for (long long j = 0; j < (m); ++j) MAXI += (long long)(vu[i][j].size());
long long blacks = 0;
for (long long i = 0; i < (n); ++i)
for (long long j = 0; j < (m); ++j) {
if (color[i][j] != '0') continue;
long long first = caca[i][j].first, second = caca[i][j].second;
long long L = tailleCycle[first][second];
if (!vu[first][second][distEnd[i][j] % L]) {
blacks++;
vu[first][second][distEnd[i][j] % L] = 1;
}
}
cout << MAXI << " " << blacks << '\n';
}
| 7 |
// Problem : B. Last Year's Substring
// Contest : Codeforces - Codeforces Round #690 (Div. 3)
// URL : https://codeforces.com/contest/1462/problem/B
// Memory Limit : 256 MB
// Time Limit : 2000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)
#include <bits/stdc++.h>
#include<map>
using namespace std;
#define ll long long int
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t,n;
string s;
cin>>t;
while(t--){
cin>>n>>s;
bool flag=false;
if(n==4){
if(s=="2020"){
cout<<"YES\n";
}
else{
cout<<"NO\n";
}
}
else{
if(s[0]=='2' && s[1]=='0' && s[2]=='2' && s[3]=='0'){
cout<<"YES\n";
flag=true;
}
else{
if(s[n-4]=='2' && s[n-3]=='0' && s[n-2]=='2' && s[n-1]=='0'){
cout<<"YES\n";
flag=true;
}
}
if(!flag){
if(s[0]=='2'){
if(s[n-3]=='0' && s[n-2]=='2' && s[n-1]=='0'){
cout<<"YES\n";
flag=true;
}
else{
if(s[1]=='0'){
if(s[n-2]=='2' && s[n-1]=='0'){
cout<<"YES\n";
flag=true;
}
else{
if(s[2]=='2' && s[n-1]=='0'){
cout<<"YES\n";
flag=true;
}
}
}
}
}
}
if(!flag)
cout<<"NO\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct triple {
long long x, y, z;
};
long long getFirst(long long n) {
for (long long i = 1;; i <<= 2) {
if (n - i > 0)
n -= i;
else
return n + i - 1;
}
}
int ord[3][3] = {0, 1, 2, 2, 0, 1, 1, 2, 0};
triple fnc(long long a) {
triple now = {0, 0, 0};
if (!a) return now;
long long n = a, m = a & 3, k = 0, who = 2;
if (!m) {
now = fnc(a + 1);
now.x -= 1, now.y -= 2, now.z -= 3;
return now;
}
m--;
while (n) n >>= 1, k++;
if (k & 1) {
now.y = 1LL << k;
k--;
now.x = 1LL << k;
a ^= now.x;
who = 0;
} else {
k--;
now.y = 1LL << k;
a ^= now.y;
k--;
now.x = 1LL << k;
if (a & now.x)
a ^= now.x;
else
who = 1;
}
now.z = now.y | now.x;
triple nxt = fnc(a);
long long ara[] = {nxt.x, nxt.y, nxt.z};
sort(ara, ara + 3,
[](long long x, long long y) { return (x & 3) < (y & 3); });
int r = ord[who][m];
now.x |= ara[(0 + r) % 3];
now.y |= ara[(1 + r) % 3];
now.z |= ara[(2 + r) % 3];
return now;
}
int main() {
int t;
cin >> t;
while (t--) {
long long n;
scanf("%lld", &n);
long long one = getFirst((n + 2) / 3);
triple data = fnc(one);
if (n % 3 == 1) printf("%lld\n", data.x);
if (n % 3 == 2) printf("%lld\n", data.y);
if (n % 3 == 0) printf("%lld\n", data.z);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long rPow(long long n, long long k) {
if (k <= 0) return 1;
return n * rPow(n, --k);
}
char a[50][50];
bool check(int x, int y, int z, int g) {
for (int w = min(x, z); w <= max(x, z); w++)
for (int q = min(y, g); q <= max(g, y); q++)
if (a[w][q] == '1') return 0;
return 1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie();
cout.tie();
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
int mx = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++) {
for (int f = 0; f < m; f++) {
if (check(i, j, k, f)) {
int per = 2 * (abs(i - k) + 1) + 2 * (abs(j - f) + 1);
mx = max(per, mx);
}
}
}
}
}
cout << mx << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, mas[1001], mod = 1000000007;
unsigned long dp[1001];
cin >> n;
for (int i = 0; i < n; cin >> mas[i++])
;
dp[0] = 1;
for (int i = 1; i <= n; i++)
dp[i] = (2 * dp[i - 1] - dp[mas[i - 1] - 1] + 2 + mod) % mod;
cout << dp[n] - 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Z = int(1e5) + 10;
long long a[Z], l[Z], n, m, k[Z], ans[Z];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> l[i];
ans[n - 1] = 1;
k[a[n - 1]]++;
for (int i = n - 2; i >= 0; i--) {
if (k[a[i]] > 0)
ans[i] = ans[i + 1];
else
ans[i] = ans[i + 1] + 1;
k[a[i]]++;
}
for (int i = 0; i < m; i++) {
cout << ans[l[i] - 1] << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long ceil(long long a, long long b) { return (a + b - 1) / b; }
long long expo(long long a, long long b, long long mod) {
long long r = 1;
while (b > 0) {
if (b & 1) r = (r * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return r;
}
void solve() {
int n;
cin >> n;
vector<string> s(n - 2);
for (int i = 0; i < n - 2; i++) {
cin >> s[i];
}
string ans;
ans += s[0];
for (int i = 1; i < n - 2; i++) {
if (s[i][0] == s[i - 1][1]) {
ans += s[i][1];
} else {
ans += s[i];
}
}
while (ans.size() != n) {
ans += "a";
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(10);
int t = 1;
cin >> t;
for (int tt = 0; tt < t; tt++) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char st[400005];
int pos[400005], ans[400005];
void solve() {
int i, j, k;
for (i = j = 0; st[i]; i++)
if (st[i] == '.') pos[j++] = i;
if (j == 0 || pos[0] > 8 || st[i - 1] == '.' || st[0] == '.') {
cout << "NO" << endl;
return;
}
pos[j] = i;
k = 0;
for (i = 0; i < j - 1; i++)
if (pos[i + 1] - pos[i] >= 3 && pos[i + 1] - pos[i] <= 12) {
if (pos[i + 1] - pos[i] >= 5)
ans[k++] = pos[i] + 3;
else
ans[k++] = pos[i] + 1;
} else {
cout << "NO" << endl;
return;
}
if (pos[i + 1] - pos[i] > 4) {
cout << "NO" << endl;
return;
}
ans[k++] = pos[i + 1] - 1;
cout << "YES" << endl;
for (i = j = 0; j < k; j++) {
for (; i <= ans[j]; i++) cout << st[i];
cout << endl;
}
}
int main() {
while (cin >> st) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, T = 1 << 18 | 1, P = 998244353;
int w[2][25], fac[N], ifac[N], n, m, a, b;
int c(int n, int m) {
return n < m ? 0 : 1ll * fac[n] * ifac[m] % P * ifac[n - m] % P;
}
int power(int a, int b) {
int t = 1;
for (; b > 0; b >>= 1, a = 1ll * a * a % P) b& 1 ? t = 1ll * t * a % P : 0;
return t;
}
int getmx(int n) {
int mx = 1;
for (; mx < n; mx <<= 1)
;
return mx;
}
void ntt(int* a, int n, int mx, bool f = 0) {
if (!f) fill(a + n, a + mx, 0);
static int rev[T];
for (int i = 0; i <= (mx - 1); ++i)
rev[i] = rev[i >> 1] >> 1 | (i & 1) * (mx >> 1),
rev[i] > i ? swap(a[i], a[rev[i]]) : void();
for (int _ = 1, k = 1; k < mx; k <<= 1, ++_)
for (int wn = w[f][_], j = 0; j < mx; j += k << 1)
for (int i = j, w = 1, t; i < j + k; ++i, w = 1ll * w * wn % P)
t = a[i + k] * 1ll * w % P, a[i + k] = (a[i] - t + P) % P,
a[i] = (a[i] + t) % P;
if (f) {
int imx = power(mx, P - 2);
for (int i = 0; i <= (mx - 1); ++i) a[i] = 1ll * a[i] * imx % P;
fill(a + n, a + mx, 0);
}
}
int* solve(int l, int r) {
if (l == r) return new int[2]{1, l};
int mid = (l + r) >> 1, *a = solve(l, mid), *b = solve(mid + 1, r);
static int at[T], bt[T];
int n = r - l + 2, na = mid - l + 2, nb = r - mid + 1, mx = getmx(n << 1),
*c = new int[n];
copy(a, a + na, at), copy(b, b + nb, bt);
ntt(at, na, mx), ntt(bt, nb, mx);
for (int i = 0; i <= (mx - 1); ++i) at[i] = 1ll * at[i] * bt[i] % P;
ntt(at, n, mx, 1), copy(at, at + n, c);
return c;
}
int main() {
scanf("%d%d%d", &n, &a, &b), m = n - a - b + 1;
if (n == 1) return printf("%d", a == 1 && b == 1), 0;
if ((a < 2 && b < 2) || m < 0) return puts("0"), 0;
for (int i = 1; i <= (23); ++i)
w[0][i] = power(3, P >> i), w[1][i] = power(3, P - 1 - (P >> i));
fac[0] = 1;
for (int i = 1; i <= (n); ++i) fac[i] = 1ll * fac[i - 1] * i % P;
ifac[n] = power(fac[n], P - 2);
for (int i = n; i >= (1); --i) ifac[i - 1] = 1ll * ifac[i] * i % P;
printf("%lld", 1ll * solve(0, n - 2)[m] * c(a - 1 + b - 1, a - 1) % P);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 100008;
int a[Max];
char ch[502][502];
int dp_row[502] = {}, dp_col[502];
long long bigmod(long long b, long long p, long long m) {
if (p == 0) return 1;
if (p % 2 == 0) {
long long temp = bigmod(b, p / 2, m);
return (temp * temp) % m;
}
return (bigmod(b, p - 1, m) * (b % m)) % m;
}
int main() {
int p, sum = 0;
cin >> p;
for (long long i = 1; i < p; i++) {
bool ok = true;
for (long long j = 1; j <= p - 2; j++)
if ((bigmod(i, j, p)) - 1 == 0) {
ok = false;
break;
}
if (ok && (bigmod(i, p - 1, p) - 1 == 0)) sum++;
}
cout << sum;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[666666];
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
for (long long i = 1; i <= 2 * n; i++) cin >> arr[i];
sort(arr + 1, arr + 1 + n * 2);
cout << arr[n + 1] - arr[n] << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int group;
cin >> group;
int room[7] = {0};
while (group--) {
string data;
cin >> data;
for (int i = 0; i < 7; i++) {
int temp = data.at(i) - '0';
room[i] += temp;
}
}
cout << *max_element(room, room + 7) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC target("avx")
const long long INF = numeric_limits<long long>::max();
const long double PI = 3.1415926535898;
const long long MOD = 998244353;
const long long LIM = 500005;
long long fpow(long long x, long long y) {
long long temp;
if (y == 0) return 1;
temp = fpow(x, y / 2);
if (y % 2 == 0)
return (temp * temp) % MOD;
else
return (x * ((temp * temp) % MOD)) % MOD;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long modInverse(long long n, long long p) { return fpow(n, p - 2); }
map<long long, long long> primeFactors(long long n) {
map<long long, long long> mp;
while (n % 2 == 0) {
if (mp.count(2) == 1)
mp[2]++;
else
mp.insert({2, 1});
n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
if (mp.count(i) == 1)
mp[i]++;
else
mp.insert({i, 1});
n = n / i;
}
}
if (n > 2) {
if (mp.count(n) == 1)
mp[n]++;
else
mp.insert({n, 1});
}
return mp;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
string a, b;
cin >> a >> b;
long long dp[n + 1][m + 1];
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= m; j++) dp[i][j] = 0;
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (a[i - 1] == b[j - 1])
dp[i][j] = 2 + dp[i - 1][j - 1];
else
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) - 1;
if (dp[i][j] < 0) dp[i][j] = 0;
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) ans = max(ans, dp[i][j]);
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ans[300005], x, previ, n;
vector<pair<int, int> > b;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
b.push_back(make_pair(x, i));
}
sort(b.begin(), b.end());
previ = b[0].first;
ans[b[0].second] = previ;
for (int i = 1; i < n; i++) {
if (previ < b[i].first) {
previ = b[i].first;
ans[b[i].second] = previ;
} else {
previ++;
ans[b[i].second] = previ;
}
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 20;
bool A[maxn][maxn];
int d[maxn];
vector<pair<int, int> > ans;
void solve(set<int> &a) {
if ((int)a.size() == 1) {
int k = *a.begin();
for (int i = 0; i < k + 1; i++)
for (int j = i + 1; j < k + 1; j++) A[i][j] = A[j][i] = 1;
return;
}
set<int> tmp;
int k = *a.rbegin(), mn = *a.begin();
for (auto x : a)
if (x != k) tmp.insert(k - x);
solve(tmp);
for (int i = 0; i <= k - mn; i++)
for (int j = i + 1; j <= k - mn; j++)
A[i][j] = !A[i][j], A[j][i] = !A[j][i];
for (int i = 0; i <= k - mn; i++)
for (int j = k - mn + 1; j <= k; j++) A[i][j] = A[j][i] = 1;
for (int i = k - mn + 1; i <= k; i++)
for (int j = i + 1; j <= k; j++) A[i][j] = A[j][i] = 1;
}
int main() {
int m;
cin >> m;
set<int> tmp;
for (int i = 0; i < m; i++) cin >> d[i], tmp.insert(d[i]);
solve(tmp);
for (int i = 0; i <= d[m - 1]; i++)
for (int j = i + 1; j <= d[m - 1]; j++)
if (A[i][j]) ans.push_back({i, j});
printf("%d\n", (int)ans.size());
for (auto x : ans) printf("%d %d\n", x.first + 1, x.second + 1);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, node[2 * 300010][26], tot[300010], cnt, num, ans;
char ch;
int add(int u, int v) {
if (!u || !v) return u + v;
int z = ++num;
cnt++;
for (int i = 0; i < 26; i++) node[z][i] = add(node[u][i], node[v][i]);
return z;
}
void dfs(int v, int dep) {
if (!v) return;
num = n + 1;
cnt = 0;
int rt = num;
for (int i = 0; i < 26; i++) rt = add(rt, node[v][i]);
tot[dep] += cnt;
for (int i = 0; i < 26; i++) dfs(node[v][i], dep + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d %c", &x, &y, &ch);
node[x][ch - 'a'] = y;
}
dfs(1, 1);
for (int i = 1; i <= n; i++)
if (tot[i] > tot[ans]) ans = i;
printf("%d\n%d", n - tot[ans], ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char grid[1500 * 2][1500 * 2];
bool svis;
int n, m, starti, startj;
void dfs(int i, int j) {
if (i < 0 || j < 0 || i >= n || j >= m || svis == 1) return;
if (grid[i][j] == 'S') {
svis = 1;
}
if (grid[i][j] == '*' || grid[i][j] == '#') return;
grid[i][j] = '*';
dfs((i + 1 + n) % n, (j + m) % m);
dfs((i + n) % n, (j + 1 + m) % m);
dfs((i - 1 + n) % n, (j + m) % m);
dfs((i + n) % n, (j - 1 + m) % m);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
if (grid[i][j] == 'S') starti = i, startj = j;
}
}
for (int i = 0; i < n * 2; i++) {
for (int j = 0; j < m * 2; j++) grid[i][j] = grid[i % n][j % m];
}
grid[starti][startj] = '.';
n *= 2;
m *= 2;
dfs(starti, startj);
if (svis)
cout << "Yes";
else
cout << "No";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653589;
long long int mod = 1000000007;
int main() {
int t = 1;
while (t--) {
long long int u, v, x;
cin >> u >> v;
x = (v - u) / 2;
if (u + v == 0) {
cout << 0;
} else if (u == v) {
cout << 1 << endl;
cout << v << endl;
} else if (u > v) {
cout << -1;
} else if ((v - u) % 2 == 1) {
cout << -1;
} else if (u == 0) {
cout << 2 << endl;
cout << v / 2 << " " << v / 2;
} else if ((u & x) == 0) {
cout << 2 << endl;
cout << x << " " << u + x;
} else {
cout << 3 << endl;
cout << (v - u) / 2 << " " << (v - u) / 2 << " " << u;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double a, b;
double mx = 0.000, mn = 1e9;
double dist(double x, double y) { return hypot(x - a, y - b); }
void ck(double x, double y) { mx = max(mx, dist(x, y)); }
double shrt(double x1, double y1, double x2, double y2) {
double area = fabs(a * y1 + x1 * y2 + x2 * b - (b * x1 + y1 * x2 + y2 * a));
double d1 = dist(x1, y1);
double d2 = dist(x2, y2);
double d3 = hypot(x1 - x2, y1 - y2);
double t1 = acos((d2 * d2 + d3 * d3 - d1 * d1) / (2 * d2 * d3));
double t2 = acos((d1 * d1 + d3 * d3 - d2 * d2) / (2 * d1 * d3));
if (t1 - 3.14159265358979323846264338327 / 2 <= 1e-8 &&
t2 - 3.14159265358979323846264338327 / 2 <= 1e-8)
return area / d3;
return min(d1, d2);
}
int main() {
int n;
cin >> n;
cin >> a >> b;
double x, y, px, py, ox, oy;
cin >> x >> y;
ck(x, y);
px = x;
py = y;
ox = x;
oy = y;
for (int i = 1; i < n; i++) {
cin >> x >> y;
ck(x, y);
mn = min(mn, shrt(x, y, px, py));
px = x;
py = y;
}
mn = min(mn, shrt(x, y, ox, oy));
printf("%.20lf\n", 3.14159265358979323846264338327 * (mx * mx - mn * mn));
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
const long long MAXN = 1e6 + 1;
using namespace std;
long long readInt() {
bool minus1 = false;
long long result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus1 = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = result * 10 + (ch - '0');
}
if (minus1)
return -result;
else
return result;
}
bool p[MAXN];
bool used[MAXN];
int main() {
int n = readInt();
for (int i = 2; i <= n; i++) {
if (!p[i]) {
for (int j = i + i; j <= n; j += i) {
p[j] = 1;
}
}
}
vector<pair<int, int>> v;
for (int i = 3; i <= (n / 2); i++) {
if (!p[i]) {
vector<int> tmp;
for (int j = i; j <= n; j += i) {
if (!used[j]) tmp.push_back(j);
}
if (tmp.size() % 2) {
v.push_back({tmp[0], tmp[2]});
used[tmp[0]] = used[tmp[2]] = 1;
for (int j = 3; j + 1 < tmp.size(); j += 2) {
v.push_back({tmp[j], tmp[j + 1]});
used[tmp[j]] = used[tmp[j + 1]] = 1;
}
} else {
for (int j = 0; j + 1 < tmp.size(); j += 2) {
v.push_back({tmp[j], tmp[j + 1]});
used[tmp[j]] = used[tmp[j + 1]] = 1;
}
}
}
}
vector<int> tmp;
for (int i = 2; i <= n; i += 2) {
if (!used[i]) tmp.push_back(i);
}
for (int j = 0; j + 1 < tmp.size(); j += 2) {
v.push_back({tmp[j], tmp[j + 1]});
used[tmp[j]] = used[tmp[j + 1]] = 1;
}
cout << v.size() << '\n';
for (auto i : v) {
cout << i.first << ' ' << i.second << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
string s;
int a[t], p, q, l;
for (int i = 0; i < t; i++) {
cin >> s;
l = s.length();
p = 0;
q = 0;
for (int g = 0; g < l; g++) {
if (s.at(g) == '0')
p++;
else
q++;
}
a[i] = fmin(p, q);
}
for (int j = 0; j < t; j++) {
if (a[j] % 2 == 1)
cout << "DA" << endl;
else
cout << "NET" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n;
cin >> n;
cin >> s;
list<char> decode;
list<char>::iterator it;
decode.push_back(s[0]);
if (n % 2 == 0) {
for (int i = 1; i < n; i++) {
if (i % 2 == 0)
decode.push_front(s[i]);
else
decode.push_back(s[i]);
}
} else {
for (int i = 1; i < n; i++) {
if (i % 2 != 0)
decode.push_front(s[i]);
else
decode.push_back(s[i]);
}
}
for (it = decode.begin(); it != decode.end(); it++) cout << *it;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
const long long MOD = 1e9 + 7;
int n;
long long DP[2][25][2];
inline int Read() {
int x = 0, f = 0;
char c = getchar();
while (!isdigit(c)) {
f |= c == '-';
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f ? -x : x;
}
inline void Write(const long long &x) {
if (x < 0) {
putchar('-');
Write(-x);
return;
}
if (x > 9) {
Write(x / 10);
}
putchar((x % 10) ^ 48);
return;
}
inline long long Solve(const int &x, const int &y) {
return (1LL << x) * (3LL - y);
}
int main() {
n = Read();
register int i, j, Log;
for (Log = -1; (1 << (Log + 1)) <= n; ++Log)
;
if ((1 << (Log - 1)) * 3 <= n) {
DP[1][Log - 1][1] = 1;
}
DP[1][Log][0] = 1;
for (i = 2; i <= n; ++i) {
for (j = 0; j <= Log; ++j) {
DP[i & 1][j][0] =
DP[(i - 1) & 1][j][0] * (n / (1LL << j) - i + 1) +
DP[(i - 1) & 1][j + 1][0] * 1LL *
(n / Solve(j, 2) - n / Solve(j + 1, 2)) +
DP[(i - 1) & 1][j][1] * 1LL * (n / Solve(j, 2) - n / Solve(j, 0));
DP[i & 1][j][1] = DP[(i - 1) & 1][j][1] * (n / ((1LL << j) * 3) - i + 1) +
DP[(i - 1) & 1][j + 1][1] * 1LL *
(n / Solve(j, 0) - n / Solve(j + 1, 0));
DP[i & 1][j][0] %= MOD, DP[i & 1][j][1] %= MOD;
}
}
Write(DP[n & 1][0][0]), putchar('\n');
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, m;
while (~scanf("%d", &n)) {
int a[1100], b[1010], p = 0, f[10100];
int i, j, k, q;
for (k = 0; k < n; k++) scanf("%d", &a[k]);
for (i = 0; i <= k; i++) {
for (j = k; j > i; j--) {
for (k = 0; k < n; k++) b[k] = a[k];
for (m = i; m <= j; m++)
if (a[m] == 1)
b[m] = 0;
else if (a[m] == 0)
b[m] = 1;
for (q = 0; q < n; q++)
if (b[q] == 1) f[p]++;
p++;
}
}
int max, tmp;
max = f[0];
for (i = 1; i < p; i++)
if (f[i] > max) max = f[i];
printf("%d\n", max);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
using ll = long long;
int n, kk, c;
ll dp[17][(1 << 16) + 1], fc[(1 << 16) + 1], a[100005], fac[105], ifac[105];
ll qpow(ll a, ll b) {
ll ret = 1;
while (b) {
if (b & 1) ret = ret * a % P;
a = a * a % P;
b >>= 1;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> kk >> c;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1,
[](int a, int b) { return ((a - kk) ^ a) < ((b - kk) ^ b); });
dp[0][0] = 1;
fac[0] = 1;
for (int i = 1; i <= kk; i++) fac[i] = fac[i - 1] * i % P;
ifac[kk] = qpow(fac[kk], P - 2);
for (int i = kk; i > 0; --i) ifac[i - 1] = ifac[i] * i % P;
int cc = 1, cur = 0;
for (int i = 1; i <= n; i++) {
while (cc <= ((a[i] - kk) ^ a[i])) cc <<= 1;
int nc = cur ^ (cur & (cc - 1));
for (int i1 = kk; i1 >= 0; --i1) {
for (int j = 0; j < cc; j++) {
int nj = nc + j;
fc[nj] = dp[i1][nj];
dp[i1][nj] = 0;
}
for (int j = 0; j < cc; j++)
if (fc[nc + j]) {
int nj = nc + j;
for (int j1 = 0; i1 + j1 <= kk; j1++)
dp[i1 + j1][nj ^ (a[i] - j1)] =
(dp[i1 + j1][nj ^ (a[i] - j1)] + fc[nj] * ifac[j1]) % P;
}
}
cur ^= a[i];
}
ll inv = qpow(n, P - 1 - kk);
for (int i = 0; i < (1 << c); i++)
cout << dp[kk][i] * fac[kk] % P * inv % P << ' ';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
long long n;
cin >> n;
long long a[n];
long long s = 0, e = 0, o = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
if (a[i] % 2 == 0)
e++;
else
o++;
}
if (s % 2 == 0)
cout << e << endl;
else
cout << o << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long oo = (long long)2 * 10e9;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, tmp_k = 0;
cin >> n >> k;
vector<vector<char>> v(n, vector<char>(n));
bool first_sea = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (first_sea) {
v[i][j] = j % 2 == 0 ? 'S' : 'L';
} else if (!first_sea) {
v[i][j] = j % 2 == 0 ? 'L' : 'S';
}
if (v[i][j] == 'L') tmp_k++;
}
first_sea = !first_sea;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (tmp_k > k) {
if (v[i][j] == 'L') {
tmp_k--;
v[i][j] = 'S';
}
} else {
break;
}
}
}
if (k == tmp_k) {
cout << "YES\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << v[i][j];
}
cout << "\n";
}
} else {
cout << "NO\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const long long MAX = 100100;
void pre() {}
void solve() {
long long n;
cin >> n;
vector<string> v(n);
for (long long i = 0; i < n; ++i) cin >> v[i];
vector<pair<long long, long long> > rm;
long long up = 0, dn = 0;
if (v[0][1] == '1') up++;
if (v[1][0] == '1') up++;
if (v[n - 1][n - 2] == '1') dn++;
if (v[n - 2][n - 1] == '1') dn++;
if (up == 0) {
if (v[n - 1][n - 2] != '1') rm.push_back({n - 1, n - 2});
if (v[n - 2][n - 1] != '1') rm.push_back({n - 2, n - 1});
} else if (dn == 0) {
if (v[1][0] != '1') rm.push_back({1, 0});
if (v[0][1] != '1') rm.push_back({0, 1});
} else if (up + dn == 4) {
rm.push_back({1, 0});
rm.push_back({0, 1});
} else if (up + dn == 0) {
rm.push_back({1, 0});
rm.push_back({0, 1});
} else if (up == 1 && dn == 1) {
if (v[n - 1][n - 2] != '1') rm.push_back({n - 1, n - 2});
if (v[n - 2][n - 1] != '1') rm.push_back({n - 2, n - 1});
if (v[1][0] != '0') rm.push_back({1, 0});
if (v[0][1] != '0') rm.push_back({0, 1});
} else if (up == 2) {
if (v[n - 1][n - 2] != '0') rm.push_back({n - 1, n - 2});
if (v[n - 2][n - 1] != '0') rm.push_back({n - 2, n - 1});
} else if (dn == 2) {
if (v[1][0] != '0') rm.push_back({1, 0});
if (v[0][1] != '0') rm.push_back({0, 1});
}
cout << ((long long)(rm).size()) << "\n";
for (auto p : rm) cout << p.first + 1 << " " << p.second + 1 << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
pre();
long long t = 1;
cin >> t;
for (long long CASE = 1; CASE <= t; ++CASE) {
solve();
}
{};
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> v;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, m, x;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
int l = n, cnt = 0;
sort(v.begin(), v.end());
while (1) {
if (l & 1)
m = l / 2;
else
m = (l / 2) - 1;
if (v[m] != k) {
v.push_back(k);
l++;
cnt++;
} else
break;
sort(v.begin(), v.end());
}
cout << cnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
int c = 0;
for (int i = 0; i < m - 1; i++) {
if (a[n - 1][i] == 'D') {
c++;
}
}
for (int i = 0; i < n - 1; i++) {
if (a[i][m - 1] == 'R') {
c++;
}
}
cout << c << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int ans[maxn];
vector<int> G[maxn];
int cnt[10];
int main() {
int n, m, x, y;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
for (auto y : G[1]) {
ans[y] = 2;
}
for (int i = 1; i <= n; i++) {
if (ans[i] == 0) {
ans[i] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (ans[i] == 2) {
for (auto y : G[i]) {
if (ans[y] == 2) {
ans[y] = 3;
}
}
break;
}
}
bool flag = 0;
for (int i = 1; i <= n; i++) {
cnt[ans[i]]++;
for (auto y : G[i]) {
if (ans[y] == ans[i]) {
flag = 1;
}
}
}
int tot = cnt[1] * cnt[2] + cnt[2] * cnt[3] + cnt[3] * cnt[1];
if (flag == 1 || cnt[1] == 0 || cnt[2] == 0 || cnt[3] == 0 || tot != m) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <class T>
inline T BigMod(T Base, T power, T M = 1000000007) {
if (power == 0) return 1;
if (power & 1)
return ((Base % M) * (BigMod(Base, power - 1, M) % M)) % M;
else {
T y = BigMod(Base, power / 2, M) % M;
return (y * y) % M;
}
}
template <class T>
inline T ModInv(T A, T M = 1000000007) {
return BigMod(A, M - 2, M);
}
int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0};
int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0};
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int N = 1e5 + 100;
vector<int> g_bi[N], g_uni[N];
int col[N];
bool cycle_found;
set<int> visited;
int comp = 0;
vector<int> node;
bool find_cycle;
int ache[N];
void cycle(int u) {
if (find_cycle) return;
col[u] = 1;
for (int v : g_uni[u]) {
if (col[v] == 1) {
find_cycle = true;
return;
}
if (col[v] == 0) cycle(v);
if (find_cycle) return;
}
col[u] = 2;
}
int vis[N];
void dfs(int u) {
vis[u] = comp;
node.push_back(u);
for (int v : g_bi[u]) {
if (vis[v] == 0) dfs(v);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g_uni[u].push_back(v);
g_bi[u].push_back(v);
g_bi[v].push_back(u);
ache[u] = ache[v] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += ache[i];
}
for (int i = 1; i <= n; i++) {
if (ache[i] && vis[i] == 0) {
comp++;
node.clear();
dfs(i);
ans--;
find_cycle = false;
for (int u : node) {
if (col[u] == 0 && find_cycle != true) {
cycle(u);
}
}
ans += find_cycle;
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ves[(int)2e5 + 6];
pair<int, int> a[(int)2e5 + 6];
int f(int p, int x) {
if (a[p].first == -1) return -1;
if (a[a[p].first].second > x) {
a[a[p].first].second -= x;
return a[p].first;
}
if (a[p].first == n) {
a[n].first = -1;
a[n].second = 0;
return -1;
}
int t = x - a[a[p].first].second;
a[a[p].first].second = 0;
a[p].first = f(a[p].first + 1, t);
return a[p].first;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
scanf("%d", ves + i), a[i].first = i, a[i].second = ves[i];
cin >> m;
while (m--) {
int t, x, p;
scanf("%d", &t);
if (t == 1)
scanf("%d %d", &p, &x), f(p, x);
else
scanf("%d", &x), printf("%d\n", ves[x] - a[x].second);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cost[3010][3010];
vector<vector<int> > g;
map<pair<int, pair<int, int> >, bool> m;
int n, mm, k;
void bfs() {
queue<pair<pair<int, int>, int> > q;
q.push(make_pair(make_pair(1, 0), 1));
cost[1][0] = 1;
while (!q.empty()) {
int u = q.front().first.first, prev = q.front().first.second,
c = q.front().second;
q.pop();
for (int i = 0; i < g[u].size(); i++) {
if (m.find(make_pair(prev, make_pair(u, g[u][i]))) == m.end() &&
(!cost[g[u][i]][u] || c + 1 < cost[g[u][i]][u])) {
cost[g[u][i]][u] = c + 1;
q.push(make_pair(make_pair(g[u][i], u), c + 1));
}
}
}
}
void print(int u, int c) {
int pos = 0;
if (u == 1) {
printf("%d ", u);
return;
}
for (int i = 0; i <= n; i++) {
if (cost[u][i] == c) {
pos = i;
}
}
print(pos, c - 1);
printf("%d ", u);
}
int main() {
cin >> n >> mm >> k;
g.resize(n + 1);
for (int i = 0; i < mm; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < k; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
m[make_pair(a, make_pair(b, c))] = 1;
}
bfs();
int mn = 2e9;
for (int i = 1; i < n; i++) {
if (cost[n][i] && cost[n][i] < mn) mn = cost[n][i];
}
if (mn != 2e9) {
printf("%d\n", mn - 1);
print(n, mn);
} else {
printf("-1");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
#define ll long long
#define endl "\n"
#define all(x) x.begin(), x.end()
#define ibase ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
const int N = 1e3 + 5, INF = 1e9 + 7;
long long a[N][N];
int main() {
ibase;
int t;
cin >> t;
while (t--) {
int n, k;
long long ans = 1;
cin >> n >> k;
for (int i = k; i >= 1; i--)
for (int j = 1; j <= n; j++)
a[i][j] = 0;
a[1][1] = 1;
for (int i = 1; i < k; i++) {
if (i % 2) {
for (int j = 1; j <= n; j++) {
ans += a[i][j];
ans = ans % INF;
a[i][j + 1] += a[i][j];
a[i + 1][j - 1] += a[i][j];
a[i + 1][j - 1] %= INF;
a[i][j + 1] %= INF;
}
}
else {
for (int j = n; j >= 1; j--) {
ans += a[i][j];
ans = ans % INF;
a[i][j - 1] += a[i][j];
a[i + 1][j + 1] += a[i][j];
a[i + 1][j + 1] %= INF;
a[i][j - 1] %= INF;
}
}
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const long long int inf = 1e9;
const long long int MOD = 1e9 + 7;
const long long int nax = 1000000 + 51;
const long long int N = nax - 1;
long long int n, fact[nax], po[nax], invfact[nax], lpf[nax];
long long int powe(long long int a, long long int n) {
long long int ans = 1;
while (n) {
if (n & 1) ans = (ans % MOD * a) % MOD;
a = (a % MOD * a) % MOD;
n /= 2;
}
return ans;
}
void pre() {
po[0] = 1;
for (long long int i = 1; i <= N; i++) po[i] = (po[i - 1] % MOD * 2LL) % MOD;
fact[0] = invfact[0] = 1;
for (long long int i = 1; i <= N; i++) {
fact[i] = (fact[i - 1] % MOD * i) % MOD;
invfact[i] = powe(fact[i], MOD - 2);
}
for (long long int i = 2; i <= N; i++) {
for (long long int j = i; j <= N; j += i) {
if (lpf[j] == 0) lpf[j] = i;
}
}
}
long long int ncr(long long int n, long long int r) {
long long int ans = fact[n];
ans = (ans % MOD * invfact[r]) % MOD;
ans = (ans % MOD * invfact[n - r]) % MOD;
return ans;
}
int main() {
ios::sync_with_stdio(0);
pre();
long long int q;
cin >> q;
while (q--) {
long long int x, y;
cin >> x >> y;
vector<int> alpha;
while (x > 1) {
long long int div = lpf[x];
long long int cnt = 0;
while (x % div == 0) {
x /= div;
cnt++;
}
alpha.push_back(cnt);
}
long long int ans = po[y - 1];
for (auto x : alpha) {
ans = (ans % MOD * ncr(x + y - 1, x)) % MOD;
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500 * 500 + 10;
struct node {
int x, y;
};
char str[MAXN];
node path[MAXN];
int ans[MAXN];
bool vis[505][505];
int main() {
int n, m, x0, y0;
scanf("%d%d%d%d", &n, &m, &x0, &y0);
scanf("%s", str);
int len = strlen(str);
int nx = x0, ny = y0, sum = 0;
for (int i = 0; i < len; i++) {
if (vis[nx][ny])
ans[i] = 0;
else
ans[i] = 1;
vis[nx][ny] = true;
sum += ans[i];
path[i].x = nx;
path[i].y = ny;
if (str[i] == 'U') {
nx = max(nx - 1, 1);
} else if (str[i] == 'R') {
ny = min(ny + 1, m);
} else if (str[i] == 'L') {
ny = max(ny - 1, 1);
} else {
nx = min(nx + 1, n);
}
}
ans[len] = n * m - sum;
for (int i = 0; i <= len; i++) {
printf("%d%c", ans[i], i == len ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 5;
const long long INF = (long long)1e18;
int n, a[MAXN], visited[MAXN];
vector<pair<int, int> > g[MAXN];
void dfs1(int from, int par, long long totalDist = 0) {
visited[from] = true;
for (int i = 0; i < g[from].size(); i++) {
int to = g[from][i].first;
int cost = g[from][i].second;
if (to != par && totalDist + cost <= a[to]) {
dfs1(to, from, max(totalDist + cost, 0LL));
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i + 1 < n; i++) {
int from, to, cost;
scanf("%d %d", &from, &cost);
from--;
to = i + 1;
g[from].push_back(make_pair(to, cost));
g[to].push_back(make_pair(from, cost));
}
dfs1(0, -1);
int ans = 0;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxx = 3e5;
const int inf = 0x3f3f3f3f;
const long long linf = 1e9;
const long long mod = 1e9 + 7;
int n, m, k;
struct EDGE {
int v, nxt;
} edge[2 * maxn];
int tot, head[maxn], out[maxn], vis[maxn][2], flag[maxn], ff;
void init() {
tot = 0, ff = 0;
memset(head, -1, sizeof(head));
memset(out, 0, sizeof(out));
memset(vis, 0, sizeof(vis));
memset(flag, 0, sizeof(flag));
}
void addEdge(int u, int v) {
edge[tot].v = v, edge[tot].nxt = head[u], head[u] = tot++;
}
void dfs(int u) {
flag[u] = 1;
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].v;
if (flag[v] == 1) {
ff = 1;
return;
} else if (flag[v] == 0)
dfs(v);
}
flag[u] = 2;
}
void bfs(int u) {
vis[u][0] = -1;
queue<pair<int, int> > q;
q.push(make_pair(u, 0));
while (q.empty() == 0) {
pair<int, int> now = q.front();
q.pop();
for (int i = head[now.first]; i != -1; i = edge[i].nxt) {
int v = edge[i].v;
int tmp = now.second ^ 1;
if (vis[v][tmp] == 0) {
vis[v][tmp] = now.first;
q.push(make_pair(v, tmp));
}
}
}
}
void print(int pre, int x) {
if (vis[pre][x ^ 1] != -1) print(vis[pre][x ^ 1], x ^ 1);
cout << pre << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
init();
int cnt, a;
for (int i = 1; i <= n; i++) {
cin >> cnt;
out[i] = cnt;
while (cnt--) {
cin >> a;
addEdge(i, a);
}
}
cin >> k;
bfs(k);
for (int i = 1; i <= n; i++) {
if (out[i] == 0) {
if (vis[i][1]) {
cout << "Win" << endl;
print(vis[i][1], 1);
cout << i << endl;
return 0;
}
}
}
dfs(k);
if (ff)
cout << "Draw" << endl;
else
cout << "Lose" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, l[100005], r[100005];
long long ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = (1); i <= (n); ++i) cin >> l[i] >> r[i];
sort(l + 1, l + n + 1);
sort(r + 1, r + n + 1);
ans = n;
for (int i = (1); i <= (n); ++i) ans += max(l[i], r[i]);
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
int main(int argc, char** argv) {
std::cin.tie(0);
std::ios_base::sync_with_stdio(0);
std::cout << std::fixed << std::setprecision(6);
int n, p;
std::cin >> n;
bool used[333333] = {0};
std::cout << 1;
for (int i = 0, j = n, c = 1; i < n; i++) {
std::cin >> p;
used[p] = true;
c++;
if (p == j) {
for (; used[j]; j--, c--)
;
}
std::cout << ' ' << c;
}
std::cout << std::endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
inline void smax(T1 &a, T2 b) {
if (a < b) a = b;
}
vector<pair<pair<int, int>, int> > edges;
int n, m;
pair<int, int> edge[100100];
int weight[100100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int w, b;
cin >> w >> b;
edges.push_back({{w, 1 - b}, i});
}
sort((edges).begin(), (edges).end());
deque<pair<int, int> > st;
char impossible = 0;
int N = 1;
for (int i = 0; i < m; ++i) {
int w = edges[i].first.first;
int type = edges[i].first.second;
int idx = edges[i].second;
if (type == 0) {
N++;
edge[idx] = {1, N};
int j = 2;
while (j < N) {
st.push_back({j, N});
if (((int)(st).size()) == m + 1) {
st.pop_back();
break;
}
++j;
}
} else {
if (((int)(st).size()) == 0) {
impossible = 1;
break;
}
auto t = st.front();
st.pop_front();
edge[idx] = t;
}
}
if (impossible)
cout << -1 << endl;
else {
for (int i = 0; i < m; ++i) {
cout << edge[i].first << ' ' << edge[i].second << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int inf = 1e9;
int mod = 998244353;
inline void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
inline void sub(int &a, int b) {
a -= b;
if (a < 0) a += mod;
}
inline int mul(int a, int b) { return (int)((long long)a * b % mod); }
inline int power(int a, long long b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
inline int inv(int a) {
a %= mod;
if (a < 0) a += mod;
int b = mod, u = 0, v = 1;
while (a) {
int t = b / a;
b -= t * a;
swap(a, b);
u -= t * v;
swap(u, v);
}
assert(b == 1);
if (u < 0) u += mod;
return u;
}
int get(int i, int j) { return ((i & 1) ^ (j & 1)); }
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
map<int, int> rset[n + 1], cset[m + 1];
map<pair<int, int>, int> val;
map<int, int> ov;
int badr = 0, badc = 0;
int cntr = 0, cntc = 0;
for (int i = 0; i < k; i++) {
int x, y, c;
cin >> x >> y >> c;
if ((int)rset[x].size() > 1) badr--;
if ((int)cset[y].size() > 1) badc--;
if (!rset[x].empty()) cntr--;
if (!cset[y].empty()) cntc--;
if (val.find({x, y}) != val.end()) {
int cc = val[{x, y}];
int rg = get(y, cc);
int cg = get(x, cc);
rset[x][rg]--;
if (!rset[x][rg]) rset[x].erase(rset[x].find(rg));
cset[y][cg]--;
if (!cset[y][cg]) cset[y].erase(cset[y].find(cg));
val.erase(val.find({x, y}));
int og = get(x + y, cc);
ov[og]--;
if (!ov[og]) ov.erase(ov.find(og));
}
if (c != -1) {
val[{x, y}] = c;
rset[x][get(y, c)]++;
cset[y][get(x, c)]++;
int og = get(x + y, c);
ov[og]++;
}
if ((int)rset[x].size() > 1) badr++;
if ((int)cset[y].size() > 1) badc++;
if (!rset[x].empty()) cntr++;
if (!cset[y].empty()) cntc++;
if (badr && badc)
cout << "0\n";
else if (!badr && badc)
cout << power(2, n - cntr) << "\n";
else if (badr)
cout << power(2, m - cntc) << "\n";
else {
int ans = power(2, n - cntr);
add(ans, power(2, m - cntc));
if (cntr + cntc) {
if (ov.size() == 1) sub(ans, 1);
} else
sub(ans, 2);
cout << ans << "\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
const int N = 1e5 + 7;
const int MAX = 1e9 + 1;
int n, k, x;
int mp[1024];
int mpT[1024];
int main() {
int i, j;
cin >> n >> k >> x;
for (i = 0; i < n; ++i) {
int t;
cin >> t;
++mp[t];
}
for (i = 0; i < k; ++i) {
bool f = true;
memset(mpT, 0, sizeof(mpT));
for (j = 0; j < 1024; ++j) {
if (!mp[j]) continue;
if (f) {
if (mp[j] % 2 == 1) {
mpT[j] += mp[j] >> 1;
mpT[j ^ x] += (mp[j] >> 1) + 1;
f = false;
} else {
mpT[j] += mp[j] >> 1;
mpT[j ^ x] += mp[j] >> 1;
}
} else {
if (mp[j] % 2 == 1) {
mpT[j] += (mp[j] >> 1) + 1;
mpT[j ^ x] += mp[j] >> 1;
f = true;
} else {
mpT[j] += mp[j] >> 1;
mpT[j ^ x] += mp[j] >> 1;
}
}
}
memcpy(mp, mpT, sizeof(mpT));
}
int minV, maxV;
for (i = 0; i < 1024; ++i) {
if (mp[i]) {
minV = i;
break;
}
}
for (i = 1024 - 1; i >= 0; --i) {
if (mp[i]) {
maxV = i;
break;
}
}
cout << maxV << ' ' << minV << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a, ax, b, bx, i, ans, h, m, x, y, z;
char c;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> a >> ax;
cin >> b >> bx;
cin >> h >> c >> m;
x = 300;
y = h * 60 + m;
z = 24 * 60 - 1;
for (i = x; i <= z; i += b) {
if (min(i + bx, y + ax) > max(i, y)) {
ans++;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int w, h;
long long c[3][3];
int inv[10];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long collinear(int w, int h) {
long long ret = 0;
for (int w0 = 0; w0 <= w; ++w0)
for (int h0 = 0; h0 <= h; ++h0)
if (w0 + h0 != 0) {
long long tmp = (long long)(w - w0 + 1) * (h - h0 + 1) % MOD *
(gcd(w0, h0) - 1) % MOD;
if (w0 == 0 || h0 == 0)
ret = (ret + tmp) % MOD;
else
ret = (ret + tmp * 2) % MOD;
}
return ret;
}
long long C(int x, int y) {
long long ret = 1;
for (int i = 1; i <= y; ++i) {
ret = ret * (x - i + 1) % MOD * inv[i] % MOD;
}
return ret;
}
void calcInv(int n) {
inv[1] = 1;
for (int i = 2; i <= 10; i++) {
inv[i] = (MOD - MOD / i) * inv[(int)(MOD % i)] % MOD;
inv[i] = (inv[i] + MOD) % MOD;
}
}
int main() {
cin >> w >> h;
int w_even = w / 2 + 1;
int w_odd = (w + 1) / 2;
int h_even = h / 2 + 1;
int h_odd = (h + 1) / 2;
calcInv(3);
c[0][0] = w_even * h_even;
c[0][1] = w_even * h_odd;
c[1][0] = w_odd * h_even;
c[1][1] = w_odd * h_odd;
long long ans = C((w + 1) * (h + 1), 3) -
c[1][1] * c[1][0] % MOD * c[0][0] % MOD -
c[1][1] * c[0][1] % MOD * c[0][0] % MOD -
c[1][0] * c[0][1] % MOD * c[0][0] % MOD -
c[1][1] * c[1][0] % MOD * c[0][1] % MOD;
ans = (ans % MOD + MOD) % MOD;
ans = ans - collinear(w, h);
ans = (ans % MOD + MOD) % MOD;
ans = ans * 6 % MOD;
cout << ans << endl;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.