solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
bool prime[1000001];
long long f[1000005];
long long pow1(long long x, long long y) {
long long res = 1;
x = x % mod;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
long long divide(long long n) { return pow1(n, mod - 2); }
long long ncr(long long n, long long r) {
if (n < r) return 0;
return (f[n] * ((divide(f[r]) * divide(f[n - r])) % mod)) % mod;
}
void sieve() {
memset(prime, true, sizeof(prime));
for (long long i = 2; i * i <= 1000000; i++)
if (prime[i])
for (long long j = i * i; j <= 1000000; j += i) prime[j] = false;
prime[0] = prime[1] = false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long l, i, n, j;
cin >> l;
string a, a1, a2;
cin >> a;
n = a.length();
if (l > n) {
cout << 1;
for (i = 1; i < l; i++) cout << 0;
} else if (l == n) {
for (i = n - 1; i >= 0; i--)
if (a[i] != '9') {
a[i]++;
break;
} else
a[i] = '0';
if (a[0] == '0') {
a[0] = '1';
cout << a;
}
cout << a;
} else {
if (n % l) {
string a3;
a3 += '1';
for (j = 1; j < l; j++) a3 += '0';
for (j = 0; j <= n / l; j++) cout << a3;
} else {
for (i = 0; i < l; i++) a1 += a[i];
for (i = 0; i < n / l; i++) a2 += a1;
if (a2 <= a) {
for (i = l - 1; i >= 0; i--)
if (a1[i] != '9') {
a1[i]++;
break;
} else
a1[i] = '0';
if (a1[0] == '0') {
a1[0] = '1';
cout << a1;
}
for (i = 1; i <= n / l; i++) cout << a1;
} else
cout << a2;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size(), ans = 0, k1 = -1;
for (int k = 0; k < n - 3; k++)
if (s.substr(k, 4) == "bear") {
int a1 = (k - k1) * (n - k - 3);
ans += a1;
k1 = k;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 7;
const int INF = 1e9 + 7;
int n, c, p_1[N], p_2[N], t_1[N], t_2[N], ans_1, ans_2, T_1, T_2;
int main() {
cin >> n >> c;
for (int i = 1; i <= n; i++) {
cin >> p_1[i];
p_2[i] = p_1[i];
}
for (int i = 1; i <= n; i++) {
cin >> t_1[i];
t_2[i] = t_1[i];
}
reverse(t_2 + 1, t_2 + 1 + n);
reverse(p_2 + 1, p_2 + 1 + n);
for (int i = 1; i <= n; i++) {
T_1 += t_1[i];
T_2 += t_2[i];
ans_1 += max(0, p_1[i] - T_1 * c);
ans_2 += max(0, p_2[i] - T_2 * c);
}
if (ans_1 < ans_2) {
cout << "Radewoosh\n";
} else if (ans_2 < ans_1) {
cout << "Limak\n";
} else {
cout << "Tie\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int times[100005];
int sum;
int ans[100005];
int num[100005];
int pos[100005];
struct q {
int l;
int r;
int id;
} a[100005];
int n, m;
void init() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
int block = int(sqrt(n));
for (int i = 1; i <= n; i++) pos[i] = (i - 1) / block + 1;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i].l, &a[i].r);
a[i].id = i;
}
}
bool cmp(q a, q b) {
if (pos[a.l] == pos[b.l]) return a.r < b.r;
return pos[a.l] < pos[b.l];
}
void upd(int x, int op) {
if (num[x] > 100000) return;
if (times[num[x]] == num[x]) sum--;
if (op == 1)
times[num[x]]++;
else
times[num[x]]--;
if (times[num[x]] == num[x]) sum++;
}
int main() {
init();
sort(a + 1, a + 1 + m, cmp);
sum = 0;
for (int i = 1; i <= n; i++) upd(i, 1);
for (int i = 1, l = 1, r = n; i <= m; i++) {
while (l < a[i].l) upd(l++, 0);
while (l > a[i].l) upd(--l, 1);
while (r < a[i].r) upd(++r, 1);
while (r > a[i].r) upd(r--, 0);
ans[a[i].id] = sum;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
template <typename first, typename second>
ostream& operator<<(ostream& os, const pair<first, second>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ",";
os << *it;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream& operator<<(ostream& os, const map<first, second>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello&... rest) {
cerr << arg << ' ';
faltu(rest...);
}
int n;
int k[2];
int s[2][7005];
int dp[2][7005];
int b[2][7005];
queue<pair<int, int> > q;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 0; i < 2; ++i) {
cin >> k[i];
for (int j = 0; j < k[i]; ++j) {
cin >> s[i][j];
}
}
dp[0][1] = dp[1][1] = 0;
q.push(make_pair(0, 1));
q.push(make_pair(1, 1));
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
for (int i = 0; i < k[p.first ^ 1]; ++i) {
int node = p.second - s[p.first ^ 1][i];
if (node < 1) node += n;
if (dp[p.first ^ 1][node] == -1) {
dp[p.first ^ 1][node] = 1;
for (int j = 0; j < k[p.first]; ++j) {
int node2 = node - s[p.first][j];
if (node2 < 1) node2 += n;
if (dp[p.first][node2] == -1) {
++b[p.first][node2];
if (b[p.first][node2] == k[p.first]) {
dp[p.first][node2] = 0;
q.push(make_pair(p.first, node2));
}
}
}
}
}
}
for (int i = 2; i <= n; ++i) {
if (dp[0][i] == -1)
cout << "Loop ";
else if (dp[0][i] == 1)
cout << "Win ";
else if (dp[0][i] == 0)
cout << "Lose ";
}
cout << '\n';
for (int i = 2; i <= n; ++i) {
if (dp[1][i] == -1)
cout << "Loop ";
else if (dp[1][i] == 1)
cout << "Win ";
else if (dp[1][i] == 0)
cout << "Lose ";
}
cout << '\n';
}
| 3 |
#include<bits/stdc++.h>
#define int long long
#define mod 1000000007
#define for1(i, n) for(int i = 1; i <= (n);i++)
using namespace std;
int input() {
int r;
scanf("%lld", &r);
return r;
}
int f1(int a, int p) {
if (p == 1)return a;
if (p % 2)return f1(a, p - 1) * a % mod;
else {
return f1(a * a % mod, p / 2) % mod;
}
}
int n, d; vector<int>a[123456];
signed main() {
n = input();
for1(i, n) a[input()].push_back(i);
for1(i, n) if (a[i].size() == 2) {
d = a[i][1] - a[i][0] + 1; d = n + 1 - d;
break;
}
int ans0 = 1, ans1 = 1, ans11 = 1, ans2 = 0;
for1(i, n + 1) {
if (i >= 2)ans2 = ans1;
if (i >= 1)ans1 = ans0;
ans0 *= n - i; ans0 %= mod; ans0 *= f1(i, mod - 2); ans0 %= mod;
cout << (ans0 + ans1 * 2 - ans11 + ans2 + mod) % mod;
printf("\n");
ans11 *= d - i + 1; ans11 %= mod; ans11 *= f1(i, mod - 2); ans11 %= mod;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_BUF_SIZE = 16384;
char BUFOR[MAX_BUF_SIZE];
int BUF_SIZE, BUF_POS;
char ZZZ;
const int MXN = 1000010;
const int C = 262144;
const int INF = 1000000001;
int a[MXN];
int n;
void test() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long int res = 0;
res = a[1];
for (int i = 2; i <= n; i++) res += 1LL + (long long int)(a[i] - 1) * i;
cout << res << endl;
}
int main() {
int te = 1;
while (te--) test();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const double PI = acos(-1.0);
const double EPS = 1e-9;
struct Point {
long long x;
long long y;
Point() {
x = 0LL;
y = 0LL;
}
Point(long long _x, long long _y) {
x = _x;
y = _y;
}
};
struct Vector {
long long x;
long long y;
Vector() {
x = 0LL;
y = 0LL;
}
Vector(long long _x, long long _y) {
x = _x;
y = _y;
}
Vector(Point p1, Point p2) {
x = p2.x - p1.x;
y = p2.y - p1.y;
}
};
istream &operator>>(istream &in, Point &p) { return in >> p.x >> p.y; }
bool operator!=(const Vector &v1, const Vector &v2) {
return v1.x != v2.x || v1.y != v2.y;
}
long long dot_product(Vector v1, Vector v2) {
return v1.x * v2.x + v1.y * v2.y;
}
long long cross_product(Vector v1, Vector v2) {
return v1.x * v2.y - v1.y * v2.x;
}
const int MAX_N = 100005;
int n;
Point points[MAX_N];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> points[i];
}
if (n % 2 == 1) {
cout << "NO";
return 0;
}
for (int i = 0; i < n / 2 - 1; i++) {
Vector v1 = Vector(points[i], points[i + 1]);
Vector v2 = Vector(points[i + 1 + n / 2], points[i + n / 2]);
if (v1 != v2) {
cout << "NO";
return 0;
}
}
Vector v1 = Vector(points[n / 2 - 1], points[n / 2]);
Vector v2 = Vector(points[0], points[n - 1]);
if (v1 != v2) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
cin.sync_with_stdio(false);
solve();
return 0;
}
char s[4020][4020];
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s[i];
reverse(s[i], s[i] + n);
}
int revgor[4020], revvert[4020];
int ans = 0;
memset(revgor, 0, sizeof(revgor));
memset(revvert, 0, sizeof(revvert));
for (int sum = 0; sum < n - 1; ++sum) {
for (int i = 0; i <= sum; ++i) {
int j = sum - i;
if ((s[i][j] + revgor[i] + revvert[j]) % 2) {
++ans;
revgor[i] = !revgor[i];
revvert[j] = !revvert[j];
}
}
}
for (int i = 0; i < n; ++i) {
s[i][n - 1 - i] += revvert[n - 1 - i] + revgor[i];
}
memset(revgor, 0, sizeof(revgor));
memset(revvert, 0, sizeof(revvert));
for (int sum = 2 * n - 2; sum > n - 1; --sum) {
for (int i = 0; i <= sum; ++i) {
int j = sum - i;
if (j >= n) continue;
if ((s[i][j] + revgor[i] + revvert[j]) % 2) {
++ans;
revgor[i] = !revgor[i];
revvert[j] = !revvert[j];
}
}
}
for (int i = 0; i < n; ++i) {
s[i][n - 1 - i] += revvert[n - 1 - i] + revgor[i];
}
for (int i = 0; i < n; ++i) {
if (s[i][n - 1 - i] % 2) {
++ans;
}
}
cout << ans;
}
| 3 |
#include<iostream>
int main(){int a,b,c;std::cin>>a>>b>>c;std::cout<<(b/a>c?c:b/a);} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
ll N,M;
ll mo;
ll dp[6020][12040];
void solve() {
int i,j,k,l,r; string s;
cin>>N>>M;
mo=M;
dp[0][6005]=1;
int x,y,z;
FOR(x,3*N+1) FOR(y,12021) if(dp[x][y]) {
// 1
(dp[x+1][y+1]+=dp[x][y])%=mo;
// 2
(dp[x+2][y-1]+=dp[x][y]*(x+1))%=mo;
// 3
(dp[x+3][y]+=dp[x][y]*(x+2)*(x+1))%=mo;
}
ll ret=0;
for(y=6005;y<=12010;y++) ret+=dp[3*N][y];
cout<<ret%mo<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch;
while (!isdigit(ch = getchar()))
;
x = ch - 48;
while (isdigit(ch = getchar())) x = x * 10 + ch - 48;
return x;
}
const int MAXN = 2e5 + 5;
int n, m, k;
vector<pair<int, int> > t[4], tmp;
vector<int> ans;
inline int calc(int x) {
int ned = max(0, k - x), tot = 0;
if (ned > min(t[1].size(), t[2].size())) return 1e9;
for (int i = 0; i < x; i++) tot += t[3][i].first;
for (int i = 0; i < ned; i++) tot += t[1][i].first + t[2][i].first;
tmp.clear();
for (auto p : t[0]) tmp.push_back(p);
for (int i = x; i < t[3].size(); i++) tmp.push_back(t[3][i]);
for (int i = ned; i < t[2].size(); i++) tmp.push_back(t[2][i]);
for (int i = ned; i < t[1].size(); i++) tmp.push_back(t[1][i]);
sort(tmp.begin(), tmp.end());
for (int i = 0; i < m - x - 2 * ned; i++) tot += tmp[i].first;
return tot;
}
int main() {
n = read(), m = read(), k = read();
int tp1 = 0, tp2 = 0, tp3 = 0;
for (int i = 1, x, a, b; i <= n; i++)
x = read(), a = read(), b = read(), t[2 * a + b].push_back(make_pair(x, i)),
tp1 += a, tp2 += b, tp3 += a & b;
if (tp1 < k || tp2 < k || 2 * k - tp3 > m) {
puts("-1");
return 0;
}
for (int i = 0; i <= 3; i++) sort(t[i].begin(), t[i].end());
int l = max(0, 2 * k - m), r = t[3].size();
while (l < r) {
int mid1 = (2 * l + r) / 3, mid2 = (2 * r + l + 2) / 3;
if (calc(mid1) < calc(mid2))
r = mid2 - 1;
else
l = mid1 + 1;
}
int ned = max(0, k - l), tot = 0;
for (int i = 0; i < l; i++)
tot += t[3][i].first, ans.push_back(t[3][i].second);
for (int i = 0; i < ned; i++)
tot += t[1][i].first + t[2][i].first, ans.push_back(t[1][i].second),
ans.push_back(t[2][i].second);
tmp.clear();
for (auto p : t[0]) tmp.push_back(p);
for (int i = l; i < t[3].size(); i++) tmp.push_back(t[3][i]);
for (int i = ned; i < t[2].size(); i++) tmp.push_back(t[2][i]);
for (int i = ned; i < t[1].size(); i++) tmp.push_back(t[1][i]);
sort(tmp.begin(), tmp.end());
for (int i = 0; i < m - l - 2 * ned; i++)
tot += tmp[i].first, ans.push_back(tmp[i].second);
printf("%d\n", tot);
for (int x : ans) printf("%d ", x);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
} point[100010];
int n;
int maxn[100010][2];
int minn[100010][2];
bool cmp1(Point a, Point b) { return a.x < b.x; }
long long solve() {
long long st = 0, ed = (long long)200000000 * (long long)200000000;
long long mid;
long long maxx, minx;
while (st <= ed) {
mid = (st + ed) >> 1;
bool ok = false;
for (int i = 1, j = 1; j <= n; j++) {
while ((long long)(point[j].x - point[i].x) *
(long long)(point[j].x - point[i].x) >
mid)
i++;
maxx = max(maxn[i - 1][0], maxn[j + 1][1]);
minx = min(minn[i - 1][0], minn[j + 1][1]);
if (minx > maxx) {
ok = true;
break;
}
if ((maxx - minx) * (maxx - minx) > mid) continue;
if ((long long)point[i].x * (long long)point[i].x + minx * minx > mid)
continue;
if ((long long)point[j].x * (long long)point[j].x + maxx * maxx > mid)
continue;
if ((long long)point[i].x * (long long)point[i].x + maxx * maxx > mid)
continue;
if ((long long)point[j].x * (long long)point[j].x + minx * minx > mid)
continue;
ok = true;
break;
}
if (ok)
ed = mid - 1;
else
st = mid + 1;
}
return st;
}
int main() {
while (cin >> n) {
int tempx, tempy;
for (int i = 1; i <= n; i++) scanf("%d%d", &point[i].x, &point[i].y);
sort(point + 1, point + n + 1, cmp1);
maxn[0][0] = -INT_MAX;
maxn[n + 1][1] = -INT_MAX;
minn[0][0] = INT_MAX;
minn[n + 1][1] = INT_MAX;
for (int i = 1; i <= n; i++) {
maxn[i][0] = max(maxn[i - 1][0], point[i].y);
maxn[n + 1 - i][1] = max(maxn[n + 2 - i][1], point[n + 1 - i].y);
minn[i][0] = min(minn[i - 1][0], point[i].y);
minn[n + 1 - i][1] = min(minn[n + 2 - i][1], point[n + 1 - i].y);
}
long long ans = min((long long)(maxn[n][0] - minn[n][0]) *
(long long)(maxn[n][0] - minn[n][0]),
(long long)(point[n].x - point[1].x) *
(long long)(point[n].x - point[1].x));
ans = min(ans, solve());
for (int i = 1; i <= n; i++) {
int temp = point[i].x;
point[i].x = point[i].y;
point[i].y = temp;
}
sort(point + 1, point + n + 1, cmp1);
maxn[0][0] = -INT_MAX;
maxn[n + 1][1] = -INT_MAX;
minn[0][0] = INT_MAX;
minn[n + 1][1] = INT_MAX;
for (int i = 1; i <= n; i++) {
maxn[i][0] = max(maxn[i - 1][0], point[i].y);
maxn[n + 1 - i][1] = max(maxn[n + 2 - i][1], point[n + 1 - i].y);
minn[i][0] = min(minn[i - 1][0], point[i].y);
minn[n + 1 - i][1] = min(minn[n + 2 - i][1], point[n + 1 - i].y);
}
ans = min(ans, solve());
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, K = 3005;
struct node {
int l, r, tim, id;
} q[N];
struct node2 {
int v, id, kd;
} ls[N];
struct node3 {
int p, v;
} q2[N];
int n, m, nn, q1, qt, now, opt, size, size2, bl[N], a[N], ans[N], tot[N],
totk[K], cnt[N], bl2[N];
bool cmd(node a, node b) {
if (bl[a.l] < bl[b.l]) return true;
if (bl[a.l] > bl[b.l]) return false;
if (bl[a.r] < bl[b.r]) return true;
if (bl[a.r] > bl[b.r]) return false;
return a.tim < b.tim;
}
bool cmd2(node2 a, node2 b) { return a.v < b.v; }
void add(int k) {
if (--tot[cnt[k]] == 0) --totk[bl2[cnt[k]]];
if (tot[++cnt[k]]++ == 0) ++totk[bl2[cnt[k]]];
}
void del(int k) {
if (--tot[cnt[k]] == 0) --totk[bl2[cnt[k]]];
if (tot[--cnt[k]]++ == 0) ++totk[bl2[cnt[k]]];
}
int getans() {
for (int i = 1; i <= bl2[now]; ++i)
if (totk[i] != size2)
for (int j = (i - 1) * size2 + 1; j <= min(now, i * size2); ++j)
if (!tot[j]) return j;
}
int main() {
scanf("%d%d", &n, &m);
nn = n;
size = pow(n, 0.6666);
if (!size) size = 1;
for (int i = 1; i <= n; ++i)
scanf("%d", &ls[i].v), ls[i].id = i, ls[i].kd = 1,
bl[i] = (i - 1) / size + 1;
for (int i = 1; i <= m; ++i) {
scanf("%d", &opt);
if (opt == 1)
++q1, scanf("%d%d", &q[q1].l, &q[q1].r), q[q1].tim = qt, q[q1].id = q1;
else
++qt, scanf("%d%d", &q2[qt].p, &q2[qt].v), ls[++nn].v = q2[qt].v,
ls[nn].id = qt, ls[nn].kd = 2;
}
if (q1) sort(q + 1, q + 1 + q1, cmd);
if (nn) sort(ls + 1, ls + 1 + nn, cmd2);
for (int i = 1; i <= nn; ++i) {
if (ls[i].v != ls[i - 1].v) ++now;
if (ls[i].kd == 1)
a[ls[i].id] = now;
else
q2[ls[i].id].v = now;
}
size2 = sqrt(now);
if (!size2) size2 = 1;
for (int i = 1; i <= now; ++i) bl2[i] = (i - 1) / size2 + 1;
for (int l = 1, r = 0, tim = 0, i = 1; i <= q1; ++i) {
while (r < q[i].r) add(a[++r]);
while (l > q[i].l) add(a[--l]);
while (r > q[i].r) del(a[r--]);
while (l < q[i].l) del(a[l++]);
while (tim < q[i].tim) {
++tim;
if (l <= q2[tim].p && q2[tim].p <= r) {
del(a[q2[tim].p]);
swap(q2[tim].v, a[q2[tim].p]);
add(a[q2[tim].p]);
} else
swap(q2[tim].v, a[q2[tim].p]);
}
while (tim > q[i].tim) {
if (l <= q2[tim].p && q2[tim].p <= r) {
del(a[q2[tim].p]);
swap(q2[tim].v, a[q2[tim].p]);
add(a[q2[tim].p]);
} else
swap(q2[tim].v, a[q2[tim].p]);
--tim;
}
ans[q[i].id] = getans();
}
for (int i = 1; i <= q1; ++i) printf("%d\n", ans[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num[6][3] = {{0, 1, 2}, {1, 0, 2}, {1, 2, 0},
{2, 1, 0}, {2, 0, 1}, {0, 2, 1}};
int n, x;
cin >> n >> x;
int t = n % 6;
printf("%d\n", num[t][x]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int _max = 1e9;
int a[maxn], b[maxn];
int dp[maxn];
vector<int> pos[maxn];
int main() {
int n, m, s, e;
scanf("%d%d%d%d", &n, &m, &s, &e);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
pos[b[i]].push_back(i);
}
for (int i = 1; i <= maxn; i++) pos[i].push_back(_max);
int time = s / e;
dp[0] = 0;
for (int i = 1; i <= time; i++) dp[i] = _max - 1;
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = time; j > 0; j--) {
dp[j] = min(dp[j],
*upper_bound(pos[a[i]].begin(), pos[a[i]].end(), dp[j - 1]));
if ((s - j * e - i >= dp[j]) && j > ans) ans = j;
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <int MOD_> struct modnum {
static constexpr int MOD = MOD_;
static_assert(MOD_ > 0, "MOD must be positive");
private:
using ll = long long;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) { if (v < 0) v += MOD; }
explicit operator int() const { return v; }
friend std::ostream& operator << (std::ostream& out, const modnum& n) { return out << int(n); }
friend std::istream& operator >> (std::istream& in, modnum& n) { ll v_; in >> v_; n = modnum(v_); return in; }
friend bool operator == (const modnum& a, const modnum& b) { return a.v == b.v; }
friend bool operator != (const modnum& a, const modnum& b) { return a.v != b.v; }
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
friend modnum inv(const modnum& m) { return m.inv(); }
modnum neg() const {
modnum res;
res.v = v ? MOD-v : 0;
return res;
}
friend modnum neg(const modnum& m) { return m.neg(); }
modnum operator- () const {
return neg();
}
modnum operator+ () const {
return modnum(*this);
}
modnum& operator ++ () {
v ++;
if (v == MOD) v = 0;
return *this;
}
modnum& operator -- () {
if (v == 0) v = MOD;
v --;
return *this;
}
modnum& operator += (const modnum& o) {
v += o.v;
if (v >= MOD) v -= MOD;
return *this;
}
modnum& operator -= (const modnum& o) {
v -= o.v;
if (v < 0) v += MOD;
return *this;
}
modnum& operator *= (const modnum& o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum& operator /= (const modnum& o) {
return *this *= o.inv();
}
friend modnum operator ++ (modnum& a, int) { modnum r = a; ++a; return r; }
friend modnum operator -- (modnum& a, int) { modnum r = a; --a; return r; }
friend modnum operator + (const modnum& a, const modnum& b) { return modnum(a) += b; }
friend modnum operator - (const modnum& a, const modnum& b) { return modnum(a) -= b; }
friend modnum operator * (const modnum& a, const modnum& b) { return modnum(a) *= b; }
friend modnum operator / (const modnum& a, const modnum& b) { return modnum(a) /= b; }
};
template <typename T> T pow(T a, long long b) {
assert(b >= 0);
T r = 1; while (b) { if (b & 1) r *= a; b >>= 1; a *= a; } return r;
}
using num = modnum<int(1e9) + 7>;
vector<num> fact, ifact;
void init() {
const int N = 123;
fact.resize(N);
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = fact[i-1] * i;
ifact.resize(N);
ifact.back() = inv(fact.back());
for (int i = N-1; i >= 1; i--) ifact[i-1] = ifact[i] * i;
}
num ncr(int n, int r) {
return fact[n] * ifact[r] * ifact[n-r];
}
num eval(const vector<num>& poly, num x) {
num res = 0;
for (int i = int(poly.size())-1; i >= 0; i--) {
res = res * x + poly[i];
}
return res;
}
num f(int n) {
num res = 0;
for (int i = 0; 2*i+5 <= n; i++) {
res += ncr(i+4, 4) * ncr(n-2*i+5, 10);
}
return res;
}
vector<num> interpolate(const vector<num>& X, const vector<num>& Y) {
int N = int(X.size());
vector<num> prod(N+1);
prod[0] = 1;
for (int i = 0; i < N; i++) {
for (int j = i; j >= 0; j--) {
prod[j+1] += prod[j];
prod[j] *= -X[i];
}
}
vector<num> res(N);
for (int i = 0; i < N; i++) {
if (int(X[i])) {
num xinv = num(1) / (-X[i]);
for (int j = 0; j < N; j++) {
prod[j] *= xinv;
prod[j+1] -= prod[j];
}
} else {
assert(!int(prod[0]));
for (int j = 0; j < N; j++) {
prod[j] = prod[j+1];
}
}
num extra = 1;
for (int j = 0; j < N; j++) {
if (i != j) {
extra *= X[i] - X[j];
}
}
extra = num(1) / num(extra);
extra *= Y[i];
for (int j = 0; j < N; j++) {
res[j] += extra * prod[j];
}
for (int j = N-1; j >= 0; j--) {
prod[j+1] += prod[j];
prod[j] *= -X[i];
}
}
return res;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
init();
vector<num> polys[2];
for (int z = 0; z < 2; z++) {
vector<num> xs, ys;
for (int x = 0; x <= 15; x++) {
xs.push_back(x);
ys.push_back(f(2*x+5+z));
}
polys[z] = interpolate(xs, ys);
}
int q;
cin >> q;
for (int j = 0; j < q; j++) {
int n;
cin >> n;
if (n <= 4) {
cout << 0 << '\n';
} else {
cout << eval(polys[(n-5)%2], (n-5)/2) << '\n';
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int solve() {
long long n;
cin >> n;
vector<int> a(n);
for (int(i) = 0; (i) < n; (i)++) {
cin >> a[i];
}
if (a[n - 1] == 15)
cout << "DOWN";
else if (a[n - 1] == 0)
cout << "UP";
else if (n == 1)
cout << -1;
else if (a[n - 2] > a[n - 1])
cout << "DOWN";
else
cout << "UP";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int ttt = 1;
while (ttt--) {
solve();
}
return 0;
}
| 1 |
#include<iostream>
int main()
{
int a,b,c,d;
std::cin>>a>>b>>c>>d;
if(a*b>c*d)std::cout<<a*b;
else std::cout<<c*d;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long mul(long long a, long long b) {
long long res = ((a % 1000000007) * (b % 1000000007)) % 1000000007;
return res;
}
long long power(long long a, long long b) {
if (!b) return 1ll;
long long res = power(a, b / 2);
res = mul(res, res);
if (b & 1) res = mul(res, a);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t;
t = 1;
while (t--) {
long long n;
cin >> n;
long long mat[n][n];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
mat[i][j] = (i * n) + (j + 1);
}
}
long long lev[n];
lev[n - 1] = -1;
for (long long i = n - 1 - 1; ~i; i--)
if (lev[i + 1] == -1)
lev[i] = 1;
else
lev[i] = -1;
long long curindx[n];
curindx[n - 1] = n - 1;
for (long long i = n - 1 - 1; ~i; i--)
if (curindx[i + 1] == n - 1)
curindx[i] = 0;
else
curindx[i] = n - 1;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
cout << mat[j][curindx[j]] << " ";
curindx[j] += lev[j];
}
cout << "\n";
}
}
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <numeric>
#include <cctype>
#include <tuple>
#include <array>
#include <climits>
#include <bitset>
#include <cassert>
#include <unordered_map>
#ifdef _MSC_VER
#include <agents.h>
#endif
#define FOR(i, a, b) for(int i = (a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define REV(v) v.rbegin(), v.rend()
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define UNIQUE(v) (v).erase(unique(ALL(v)), (v).end())
#define MP make_pair
#define MT make_tuple
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
struct MinCostFlow{
struct edge{
int to, cost, rev, cap;
edge(int to, int cost, int rev, int cap) :to(to), cost(cost), rev(rev), cap(cap){}
};
int n;
vector<vector<edge>> G;
void add(int from, int to, int cost, int cap){
G[from].push_back(edge(to, cost, G[to].size(), cap));
G[to].push_back(edge(from, -cost, G[from].size() - 1, 0));
}
vector<int> dist, h, prevv, preve;
static const int INF = 1e9;
MinCostFlow(int size){
n = size;
G.assign(n, vector<edge>());
dist.assign(n, 0);
h.assign(n, 0);
prevv.assign(n, 0);
preve.assign(n, 0);
}
void tdfs(int v, vector<int> &vis, vector<int> &ord){
vis[v] = 1;
for (auto e : G[v]){
if (!e.cap) continue;
if (vis[e.to]) continue;
tdfs(e.to, vis, ord);
}
ord.push_back(v);
}
void tsort(vector<int> &ord){
vector<int> vis(n);
for (int i = 0; i < n; ++i) if (!vis[i]) tdfs(i, vis, ord);
reverse(ord.begin(), ord.end());
}
void dag_mindist(int s){
fill(h.begin(), h.end(), INF);
h[s] = 0;
vector<int> ord;
tsort(ord);
for (int i = 0; i < n; ++i){
int v = ord[i];
if (h[v] == INF) continue;
for (auto e : G[v]){
if (!e.cap) continue;
h[e.to] = min(h[e.to], h[v] + e.cost);
}
}
}
int min_cost_flow(int s, int t, int f){
int res = 0;
rep(i, n) h[i] = 0;
dag_mindist(s);
while (f){
rep(i, n) dist[i] = INF;
dist[s] = 0;
priority_queue<P, vector<P>, greater<P> > q;
q.push(MP(0, s));
while (!q.empty()){
int pos = q.top().second;
int d = q.top().first;
q.pop();
if (dist[pos] < d) continue;
dist[pos] = d;
rep(i, G[pos].size()){
edge &e = G[pos][i];
if (e.cap <= 0) continue;
if (dist[pos] + e.cost + h[pos] - h[e.to] < dist[e.to]){
dist[e.to] = dist[pos] + e.cost + h[pos] - h[e.to];
prevv[e.to] = pos;
preve[e.to] = i;
q.push(MP(dist[e.to], e.to));
}
}
}
if (dist[t] == INF) return -1;
rep(i, n) h[i] += dist[i];
int d = f;
for (int v = t; v != s; v = prevv[v]){
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d*h[t];
for (int v = t; v != s; v = prevv[v]){
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[e.to][e.rev].cap += d;
}
}
return res;
}
};
const int N = 1e6 + 10;
int num[N];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(20);
int n;
cin >> n;
vector<int> a(n), b(n);
rep(i, n) cin >> a[i] >> b[i];
vector<int> c(n * 2);
rep(i, n) c[i] = a[i], c[i + n] = b[i];
sort(ALL(c));
UNIQUE(c);
int m = c.size();
rep(i, m) num[c[i]] = i;
MinCostFlow mcf(n + m + 2);
const int SRC = n + m, SNK = SRC + 1;
rep(i, n){
mcf.add(SRC, i, 0, 1);
mcf.add(i, n + num[a[i]], -b[i], 1);
mcf.add(i, n + num[b[i]], -a[i], 1);
mcf.add(i, SNK, 0, 1);
}
rep(i, m){
mcf.add(n + i, SNK, 0, 1);
}
cout << -mcf.min_cost_flow(SRC, SNK, n) << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int K, N1, N2, N3, T1, T2, T3;
short U1[30000100], U2[30000100], U3[30000100];
int main() {
scanf("%d%d%d%d%d%d%d", &K, &N1, &N2, &N3, &T1, &T2, &T3);
int ans = 0;
int ctim = 0;
for (int i = 0; i < K; ++i) {
for (;;) {
if (U1[ctim] < N1 && U2[ctim + T1] < N2 && U3[ctim + T1 + T2] < N3) break;
++ctim;
}
(ans) = max((ans), (ctim + T1 + T2 + T3));
for (int j = 0; j < T1; ++j) ++U1[ctim + j];
for (int j = T1; j < T1 + T2; ++j) ++U2[ctim + j];
for (int j = T1 + T2; j < T1 + T2 + T3; ++j) ++U3[ctim + j];
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool used[100005];
long long n, a[100006], t[500000];
vector<long long> pos[100006];
void build(int v, int vl, int vr) {
if (vl == vr) {
t[v] = used[vl];
return;
}
int vm = (vl + vr) / 2;
build(2 * v, vl, vm);
build(2 * v + 1, vm + 1, vr);
t[v] = t[2 * v] + t[2 * v + 1];
return;
}
void update(int v, int vl, int vr, int pos) {
if (vl == vr) {
t[v]--;
used[vl] = 0;
return;
}
int vm = (vl + vr) / 2;
if (pos <= vm)
update(2 * v, vl, vm, pos);
else
update(2 * v + 1, vm + 1, vr, pos);
t[v] = t[2 * v] + t[2 * v + 1];
return;
}
long long get(int v, int vl, int vr, int l, int r) {
if (l > r) return 0;
if (vl == l && vr == r) return t[v];
int vm = (vl + vr) / 2;
return get(2 * v, vl, vm, l, min(vm, r)) +
get(2 * v + 1, vm + 1, vr, max(vm + 1, l), r);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]].push_back(i);
}
for (int i = 1; i <= n; i++) used[i] = true;
build(1, 1, n);
int cur = 1, cpos = 1;
long long ans = 0;
while (cur != 100001)
if (pos[cur].size() != 0) {
if (pos[cur][0] >= cpos) {
ans += get(1, 1, n, cpos, pos[cur][pos[cur].size() - 1]);
for (int i = 0; i < pos[cur].size(); i++) update(1, 1, n, pos[cur][i]);
cpos = pos[cur][pos[cur].size() - 1] + 1;
if (cpos == n + 1) cpos = 1;
} else {
int i = 0;
while (i < pos[cur].size() && pos[cur][i] < cpos) i++;
i--;
ans += get(1, 1, n, cpos, n);
ans += get(1, 1, n, 1, pos[cur][i]);
cpos = pos[cur][i] + 1;
for (int j = 0; j < pos[cur].size(); j++) update(1, 1, n, pos[cur][j]);
}
cur++;
} else
cur++;
cout << ans << endl;
return 0;
}
| 2 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<set>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
typedef pair<int,int> pii;
int main(){
int n;
cin >> n;
vector<int> cnt(n+10, 0);
int ones = 0, border = 0;
rep(i,n){
int x;
cin >> x;
if(x >= n+10){
ones++;
cout << "Yes" << endl;
}else{
if( cnt[0] or (x <= border and ones-x > 0) ){
cout << "No" << endl;
}else{
cout << "Yes" << endl;
cnt[x]++;
while(cnt[x] == 2){
cnt[x] = 0; ones--;
x--; cnt[x]++;
}
ones++;
//cout << x << " " << border << endl;
while(cnt[border+1]) border++;
}
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, id[100005];
long long cnt, sum;
int main() {
cin >> n >> cnt;
for (int i = 1; i <= n; ++i) cin >> id[i];
for (int i = 1; i <= n; ++i) {
if (cnt - i > 0)
cnt -= i;
else {
cout << id[cnt] << '\n';
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int t, n, m, b[N], a[N];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) b[i] = 0;
int mmo = -1, mp = -1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
mmo = max(mmo, a[i]);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int p, s;
scanf("%d%d", &p, &s);
mp = max(mp, p);
b[s] = max(b[s], p);
}
for (int i = n - 1; i >= 1; i--) b[i] = max(b[i + 1], b[i]);
if (mp < mmo) {
printf("-1\n");
continue;
}
int now = -1, k = 0, ans = 0;
for (int i = 1; i <= n; i++) {
now = max(now, a[i]), k++;
if (b[k] < now) {
ans++, k = 1, now = a[i];
}
}
printf("%d\n", ans + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return x * neg;
}
inline void print(int x) {
if (x < 0) {
putchar('-');
print(abs(x));
return;
}
if (x <= 9)
putchar(x + '0');
else {
print(x / 10);
putchar(x % 10 + '0');
}
}
inline int qpow(int x, int e, int _MOD) {
int ans = 1;
while (e) {
if (e & 1) ans = ans * x % _MOD;
x = x * x % _MOD;
e >>= 1;
}
return ans;
}
int a, b, c, d, e, f;
char s[1000005][4];
signed main() {
cin >> a >> b >> c >> d >> e >> f;
if ((f - c + d - a) % 2 != 0) return puts("-1"), 0;
if ((b - a + f - e) % 2 != 0) return puts("-1"), 0;
if ((d - c + e - b) % 2 != 0) return puts("-1"), 0;
if ((c - a + e) % 2 != 0) return puts("-1"), 0;
for (int x2 = 0; x2 <= 100000; x2++) {
int x7 = x2 - (f - c + d - a) / 2;
int x4 = x2 - (b - a + f - e) / 2;
int x1 = x2 - (d - c - e + b) / 2;
int x3 = (c - a + e) / 2 - x1;
int x6 = (f - c - (d - a)) / 2 + x3;
int x5 = x3 - (b - a - (f - e)) / 2;
if (x1 < 0 || x2 < 0 || x3 < 0 || x4 < 0 || x5 < 0 || x6 < 0 || x7 < 0)
continue;
int j = 0;
cout << x1 + x2 + x3 + x4 + x5 + x6 + x7 << endl;
for (int i = 1; i <= x1; i++)
s[++j][0] = 'a', s[j][1] = 'a', s[j][2] = 'a', s[j][3] = 'b';
for (int i = 1; i <= x2; i++)
s[++j][0] = 'a', s[j][1] = 'a', s[j][2] = 'b', s[j][3] = 'a';
for (int i = 1; i <= x3; i++)
s[++j][0] = 'a', s[j][1] = 'a', s[j][2] = 'b', s[j][3] = 'b';
for (int i = 1; i <= x4; i++)
s[++j][0] = 'a', s[j][1] = 'b', s[j][2] = 'a', s[j][3] = 'a';
for (int i = 1; i <= x5; i++)
s[++j][0] = 'a', s[j][1] = 'b', s[j][2] = 'a', s[j][3] = 'b';
for (int i = 1; i <= x6; i++)
s[++j][0] = 'a', s[j][1] = 'b', s[j][2] = 'b', s[j][3] = 'a';
for (int i = 1; i <= x7; i++)
s[++j][0] = 'a', s[j][1] = 'b', s[j][2] = 'b', s[j][3] = 'b';
for (int i = 1; i <= x1 + x2 + x3 + x4 + x5 + x6 + x7; i++) cout << s[i][0];
puts("");
for (int i = 1; i <= x1 + x2 + x3 + x4 + x5 + x6 + x7; i++) cout << s[i][1];
puts("");
for (int i = 1; i <= x1 + x2 + x3 + x4 + x5 + x6 + x7; i++) cout << s[i][2];
puts("");
for (int i = 1; i <= x1 + x2 + x3 + x4 + x5 + x6 + x7; i++) cout << s[i][3];
puts("");
return 0;
}
puts("-1");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
while (k--) cout << n-- << " ";
for (int i = 1; i <= n; i++) cout << i << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[n];
bool S[n];
for (int i = 0; i < n; ++i) {
cin >> A[i];
S[i] = true;
}
int t = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (S[i] == true && S[j] == true && i != j && (A[i] + A[j]) % 3 == 0) {
S[i] = false;
S[j] = false;
++t;
}
}
}
cout << t;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1000007;
long long n, a[maxn], s[maxn];
long long get_ans(long long u) {
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
ans += min(s[i] % u, u - s[i] % u);
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
s[i] = a[i] + s[i - 1];
}
if (s[n] == 1) {
cout << -1 << endl;
return 0;
}
long long sum = s[n], q = sqrt(sum), ans = 1e18;
for (int i = 2; i <= q; ++i) {
if (sum % i == 0) {
ans = min(get_ans(i), ans);
while (sum % i == 0) sum /= i;
}
}
if (sum > 1) ans = min(get_ans(sum), ans);
cout << ans << endl;
return 0;
}
| 5 |
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
char are(char c, int i){
int tmp = ((int)(c -'0' + i))%10;
if(tmp>=0) return (char)(tmp + '0');
return (char)((tmp+10) + '0');
}
int kore(string start, string goal,int sum){
if(start.empty()) return sum;
int move = (int)(goal[0] - start[0]);
if(move==0){
start.erase(start.begin());goal.erase(goal.begin());
return kore(start,goal,sum);
}
int m=100;
if(start.length() == 1) return sum+1;
for(int i=0; i < start.length(); i++){
string str1, str2;
int j;
for( j=1; j < i+1 ; j++){
str1.push_back(are(start[j],move));
str2.push_back(goal[j]);
}
for(j=i+1; j<start.length();j++){
str1.push_back(start[j]);
str2.push_back(goal[j]);
}
m = min( kore(str1,str2,sum+1), m);
}
return m;
}
int main() {
for(;;){
int N;
cin >> N;
if(N==0) break;
string s,g;
cin >> s >> g;
cout << kore(s,g,0) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1003;
int prime[MAXN];
int initPrime(int max) {
bool isPrime[MAXN] = {false};
int p = 0;
for (int i = 2; i <= max; i++) {
if (!isPrime[i]) {
prime[p] = i;
p++;
for (int j = i + i; j <= max; j += i) {
isPrime[j] = true;
}
}
}
return p;
}
int main() {
int n;
cin >> n;
int m = initPrime(n);
int k = 0;
int ans[MAXN];
for (int i = 0; i < m; i++) {
int t = prime[i];
for (int j = t; j <= n; j *= t) {
ans[k] = j;
k++;
}
}
cout << k << endl;
for (int i = 0; i < k; i++) {
cout << ans[i] << ' ';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
int l, r, num, fen[N], wh[N], a[N], Add[N];
long long tot, fen2[N];
void add(int x, int val) {
for (; x < N; x += x & -x) {
if (val > 0) {
fen[x]++;
} else {
fen[x]--;
}
fen2[x] += val;
}
}
pair<int, long long> get(int x) {
int ret = 0;
long long ret2 = 0;
for (; x; x -= x & -x) {
ret += fen[x];
ret2 += fen2[x];
}
return {ret, ret2};
}
long long f(int l, int r) { return 1ll * (l + r) * (r - l + 1) / 2; }
long long Get(int pos) {
pair<int, long long> p = get(pos);
return p.second - f(l, l + p.first - 1) +
1ll * f(r - (num - p.first) + 1, r) - (tot - p.second);
}
int check(int pos) {
pair<int, long long> p = get(pos);
return pos - l + 1 - p.first;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
wh[a[i]] = i;
}
for (int i = n; i > 0; i--) {
Add[i] = get(a[i]).first;
add(a[i], 1);
}
memset(fen, 0, sizeof(fen));
memset(fen2, 0, sizeof(fen2));
long long ans = 0;
l = wh[1], r = wh[1];
cout << "0 ";
for (int i = 2; i <= n; i++) {
int id = wh[i];
if (id > l && id < r) {
add(id, -id);
tot -= id;
num--;
} else if (id > r) {
while (++r < id) {
num++;
tot += r;
add(r, r);
}
} else {
while (--l > id) {
num++;
tot += l;
add(l, l);
}
}
int L = l - 1, R = r + 1;
while (R - L > 1) {
int m = (L + R) / 2;
if (check(m) > i / 2)
R = m;
else
L = m;
}
ans += Add[id];
cout << ans + Get(L) << " ";
}
return 0;
}
| 3 |
#include<cstdio>
int main(){
char a[64];
while(scanf("%s",&a[0])>0){
for(int i=1;i<8;i++)
scanf("%s",&a[8*i]);
for(int i=0;i<64;i++){
if(a[i]=='1'){
if(a[i+1]=='1'){
if(a[i+2]=='1'){
puts("C");
}else if(a[i+7]=='1'){
puts("G");
}else if(a[i+8]=='1'){
puts("A");
}else{
puts("E");
}
}else{
if(a[i+7]=='1'){
puts("D");
}else if(a[i+9]=='1'){
puts("F");
}else{
puts("B");
}
}
break;
}
}
}
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
long long n;
int dfs(long long d,bool a,bool b,bool c){
if(d>n) return 0;
int res=(a&&b&&c?1:0);
res+=dfs(10*d+3,true,b,c);
res+=dfs(10*d+5,a,true,c);
res+=dfs(10*d+7,a,b,true);
return res;
}
int main(){
scanf("%lld",&n);
printf("%d\n",dfs(0,false,false,false));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int,int>;
using db = double;
using vi = vector<int>;
#define fir first
#define sec second
#define pb push_back
#define lowbit(x) ((x)&(-(x)))
struct data {
int a, b, c;
}p[200000];
int x, y, z;
ll l[200000], r[200000];
bool cmp(data x, data y) {
return x.b-x.c > y.b-y.c;
}
int main() {
scanf( "%d%d%d", &x, &y, &z );
int n = x+y+z;
for (int i = 1; i <= n; ++i)
scanf( "%d%d%d", &p[i].a, &p[i].b, &p[i].c );
sort(p+1, p+n+1, cmp);
l[y] = 0; multiset<ll> S;
for (int i = 1; i <= y; ++i) {
l[y]+=p[i].b;
S.insert(p[i].b-p[i].a);
}
for (int i = y+1; i < n-z+1; ++i) {
l[i]=l[i-1]+p[i].b;
S.insert(p[i].b-p[i].a);
auto u = S.begin();
l[i]-=*u; S.erase(u);
}
r[n-z+1] = 0; S.clear();
for (int i = n; i >= n-z+1; --i) {
r[n-z+1]+=p[i].c;
S.insert(p[i].c-p[i].a);
}
for (int i = n-z; i > y; --i) {
r[i]=r[i+1]+p[i].c;
S.insert(p[i].c-p[i].a);
auto u = S.begin();
r[i]-=*u; S.erase(u);
}
ll ans = 0;
for (int i = y; i < n-z+1; ++i)
ans = max(ans, l[i]+r[i+1]);
cout<<ans<<endl;
}
| 0 |
#include<iostream>
#include<string>
#include<math.h>
using namespace std;
int a[10][10000];
int main(){
int r,c;
while(true){
cin>>r>>c;
if(r==0&&c==0)
break;
for(int i=0;i<r;i++){
for(int j=0;j<c;j++){
cin>>a[i][j];
}
}
double rrr=r;
int best=0;
for(int i=0;i<pow(2,rrr);i++){
int count=0;
for(int j=0;j<c;j++){
int o=0;
for(int k=0;k<r;k++)
o+=a[k][j];
count+=max(o,r-o);
}
if(count>best){
best=count;
}
for(int j=0;j<r;j++){
double jjj=j;
int jjjjj=pow(2,jjj);
if((i+1)%jjjjj==0){
for(int k=0;k<c;k++){
a[j][k]=(a[j][k]+1)%2;
}
}
}
}
cout<<best<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
int N;
char s[507][507];
int rX[] = {-1, 0, 1, 0};
int rY[] = {0, -1, 0, 1};
int spoj[507][507];
int rozm[1000007];
int akt[1000007];
int terRozm;
int wyn;
void dfs(int y, int x, int num) {
spoj[y][x] = num;
terRozm++;
for (int i = 0; i < 4; i++) {
int nx = x + rX[i], ny = y + rY[i];
if (nx >= 1 && nx <= N && ny >= 1 && ny <= N) {
if (s[ny][nx] == '.' && spoj[ny][nx] == 0) dfs(ny, nx, num);
}
}
}
void dolicz(int y1, int x1, int y2, int x2, bool kk = false) {
for (int y = y1; y <= y2; y++) {
if (y < 1 || y > N) continue;
for (int x = x1; x <= x2; x++) {
if (x < 1 || x > N) continue;
if (s[y][x] == '.') {
int sp = spoj[y][x];
akt[sp]++;
if (akt[sp] == 1) wyn += rozm[sp];
} else if (kk) {
wyn++;
}
}
}
}
void odejmij(int y1, int x1, int y2, int x2, bool kk = false) {
for (int y = y1; y <= y2; y++) {
if (y < 1 || y > N) continue;
for (int x = x1; x <= x2; x++) {
if (x < 1 || x > N) continue;
if (s[y][x] == '.') {
int sp = spoj[y][x];
akt[sp]--;
if (akt[sp] == 0) wyn -= rozm[sp];
} else if (kk) {
wyn--;
}
}
}
}
int main() {
int K;
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; i++) scanf("%s", s[i] + 1);
int ileSpoj = 0;
for (int i = 1; i <= N; i++)
for (int w = 1; w <= N; w++)
if (s[i][w] == '.' && spoj[i][w] == 0) {
terRozm = 0;
dfs(i, w, ++ileSpoj);
rozm[ileSpoj] = terRozm;
}
int maxi = 0;
for (int i = 1; i <= N - K + 1; i++) {
dolicz(i, 1, i + K - 1, K, true);
dolicz(i - 1, 1, i - 1, K);
dolicz(i + K, 1, i + K, K);
dolicz(i, 0, i + K - 1, 0);
dolicz(i, K + 1, i + K - 1, K + 1);
maxi = std::max(wyn, maxi);
for (int x = 2; x <= N + 2; x++) {
odejmij(i, x - 2, i + K - 1, x - 2);
odejmij(i, x - 1, i + K - 1, x - 1, true);
dolicz(i, x - 1, i + K - 1, x - 1);
odejmij(i, x + K - 1, i + K - 1, x + K - 1);
dolicz(i, x + K - 1, i + K - 1, x + K - 1, true);
dolicz(i, x + K, i + K - 1, x + K);
odejmij(i - 1, x - 1, i - 1, x - 1);
dolicz(i - 1, x + K - 1, i - 1, x + K - 1);
odejmij(i + K, x - 1, i + K, x - 1);
dolicz(i + K, x + K - 1, i + K, x + K - 1);
maxi = std::max(wyn, maxi);
}
}
printf("%d", maxi);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T BM(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T mdINV(T a, T M) {
return BM(a, M - 2, M);
}
template <class T>
inline T PW(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>
string NTS(T Number) {
stringstream ss;
ss << Number;
return ss.str();
}
template <class T>
T stringtonumber(const string &Text) {
istringstream ss(Text);
T result;
return ss >> result ? result : 0;
}
template <class T>
bool ISLEFT(T a, T b, T c) {
if (((a.first.first - b.first.first) * (b.second.second - c.second.second) -
(b.first.first - c.first.first) * (a.second.second - b.second.second)) <
0.0)
return 1;
else
return 0;
}
int main() {
string first;
cin >> first;
string s = "BGRY";
map<char, int> mp;
do {
bool fl = 0;
for (int i = 0; i < 4; i++) {
if (first[i] == '!')
continue;
else if (first[i] != s[i])
fl = 1;
}
if (!fl) {
string h = s;
mp.clear();
for (int i = 0; i <= 3; i++)
if (first[i] == '!') {
mp[s[i]]++;
}
for (int i = 4; i < first.size(); i++) {
if (first[i] == '!') {
char t = h[i - 4];
h += t;
mp[t]++;
} else if (first[i] != h[i - 4]) {
fl = 1;
} else {
char t = h[i - 4];
h += t;
}
}
if (!fl) {
break;
}
}
} while (next_permutation(s.begin(), s.end()));
printf("%d %d %d %d\n", mp['R'], mp['B'], mp['Y'], mp['G']);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
int main() {
int N, X[200000];
cin >> N;
vector< int > vs;
for(int i = 0; i < N; i++) {
cin >> X[i];
vs.emplace_back(X[i]);
}
sort(begin(vs), end(vs));
int mex1 = vs[(N - 1) / 2];
int mex2 = vs[(N + 1) / 2];
for(int i = 0; i < N; i++) {
if(X[i] <= mex1) cout << mex2 << endl;
else cout << mex1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long int
int collatz(int n){
if(n==1) return 0;
if(n&1) return 1+collatz(3*n+1);
else return 1+collatz(n/2);
}
int32_t main(){
int n;cin>>n;if(n<=2)cout<<4;else cout<<collatz(n)+2;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=3e5+11;
int k,n,ans[N],len;
int main(){
// freopen("ex.in","r",stdin);
scanf("%d%d",&k,&n);
if(k%2==0){
printf("%d",k/2);
for(int i=1;i<n;++i) printf(" %d",k);
return 0;
}
for(int i=1;i<=n;++i) ans[i]=(k+1)/2;
int T=n/2;
len=n;
while(T--){
if(ans[len]==1) len--;
else{
ans[len]--;
while(len<n) ans[++len]=k;
}
}
for(int i=1;i<=len;++i) printf("%d ",ans[i]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long A[100001] = {0};
for (long long i = 0; i < n; i++) {
cin >> A[i];
if (A[i] >= 0) A[i] = -A[i] - 1;
}
if (n % 2 == 1) {
int min = 0;
while (A[min] == -1 && min < n) min++;
if (min == n) {
A[0] = 0;
for (int i = 0; i < n; i++) cout << A[i] << " ";
return 0;
}
for (int i = min; i < n; i++) {
if (A[i] < A[min] && A[i] != -1) min = i;
}
A[min] = -A[min] - 1;
}
for (int i = 0; i < n; i++) cout << A[i] << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int fv[10010];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
int ans = 0;
int dif = 0;
for (auto &x : s) {
fv[x]++;
if (fv[x] == 1) {
dif++;
}
if (fv[x] > 1) {
ans = 1;
}
}
if (dif == 1) {
ans = 1;
}
if (ans) {
cout << "Yes";
} else {
cout << "No";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
int num;
int minp[MAXN + 1], p[MAXN + 1];
int prime(int n = MAXN) {
num = 0;
memset(minp, 0, sizeof(minp));
for (int i = 2; i <= n; ++i) {
if (!minp[i]) p[num++] = i, minp[i] = i;
;
for (int j = 0; j < num && i * p[j] <= n; ++j) {
minp[i * p[j]] = p[j];
if (i % p[j] == 0) break;
}
}
return num;
}
int n, m, res;
int ten[10];
int cnt[10000][5];
int id[5];
void gao(int r, int c) {
if (r == n) {
int cur = 1;
for (int i = 1; i < n; ++i) {
cur *= cnt[id[i]][i];
}
res += cur;
} else {
int nr = c + 1 == r ? r + 1 : r;
int nc = c + 1 == r ? 1 : c + 1;
id[r] *= 10;
id[c] *= 10;
for (int i = 0; i < 10; ++i) {
gao(nr, nc);
++id[r];
++id[c];
}
id[c] = id[c] / 10 - 1;
id[r] = id[r] / 10 - 1;
}
}
int main() {
prime();
for (int i = ten[0] = 1; i < 7; ++i) {
ten[i] = ten[i - 1] * 10;
}
int T, v;
scanf("%d", &T);
for (int caseNum = 1; caseNum <= T; ++caseNum) {
scanf("%d", &v);
n = 0;
for (n = 0, m = v; m != 0; m /= 10, ++n)
;
memset(id, 0, sizeof(id));
for (int i = 1; i < n; ++i) {
id[i] = v / ten[n - i - 1] % 10;
}
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < num && p[i] < ten[n]; ++i) {
int d[5];
for (int j = 0, t = p[i]; j < n; d[n - 1 - j++] = t % 10, t /= 10)
;
for (int j = 1; j < n; ++j) {
int t = 0;
for (int k = 0; k < n; ++k) {
if (k != j) {
t = t * 10 + d[k];
}
}
++cnt[t][j];
}
}
res = 0;
gao(2, 1);
printf("%d\n", res);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string second;
cin >> second;
long long n = ((long long)second.size());
vector<long long> F(n, 0), B(n, 0);
for (long long i = 1; i < n; i++) {
F[i] = F[i - 1] + (second[i - 1] == '0');
}
for (long long i = n - 2; i >= 0; i--) {
B[i] = B[i + 1] + (second[i + 1] == '1');
}
long long ret = LONG_LONG_MAX;
for (long long i = 0; i < n; i++) {
ret = min({ret, F[i] + B[i], n - 1 - F[i] - B[i]});
}
{
cout << (ret) << '\n';
return;
};
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long _ = 1;
cin >> _;
for (long long i = 1; i <= _; i++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> tab[1100005];
vector<pair<int, int>> pol[1100005];
bool odw[1100005];
vector<pair<pair<int, int>, int>> out;
vector<pair<pair<int, int>, int>> w;
void dfs(int a) {
while (!pol[a].empty()) {
if (odw[pol[a].back().second])
pol[a].pop_back();
else {
w.push_back(
make_pair(make_pair(pol[a].back().first, a), pol[a].back().second));
odw[pol[a].back().second] = true;
dfs(pol[a].back().first);
}
}
if (w.empty() == false) {
out.push_back(w.back());
w.pop_back();
}
}
bool check(int a) {
for (int x = 0; x <= (1 << 20); x++)
if (pol[x].size() % 2) return false;
for (int x = 0; x <= (1 << 20); x++)
if (pol[x].size()) {
dfs(x);
break;
}
if (out.size() != a) {
out.resize(0);
return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a;
cin >> a;
for (int x = 1; x <= a; x++) {
int c, d;
cin >> c >> d;
tab[x] = make_pair(c, d);
}
if (a == 1) {
int pom = tab[1].first ^ tab[1].second;
int licz = 0;
if (pom == 0)
licz = 20;
else {
while (pom % 2 == 0) {
pom /= 2;
licz++;
}
}
cout << licz << '\n' << 1 << " " << 2;
return 0;
}
for (int x = 20; x >= 0; x--) {
int pom = (1 << x) - 1;
for (int y = 1; y <= a; y++) {
pol[tab[y].first & pom].push_back(make_pair(tab[y].second & pom, y));
pol[tab[y].second & pom].push_back(make_pair(tab[y].first & pom, y));
}
if (check(a)) {
cout << x << '\n';
for (auto x : out) {
if (x.first.first == (tab[x.second].first & pom) &&
x.first.second == (tab[x.second].second & pom))
cout << x.second * 2 - 1 << " " << x.second * 2 << " ";
else
cout << x.second * 2 << " " << x.second * 2 - 1 << " ";
}
return 0;
}
for (int x = 0; x <= (1 << 20); x++) {
pol[x].resize(0);
odw[x] = false;
}
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define N 2005
using namespace std;
int n,m;
char s[N][N];
int same[N][N];
int sta[N],top;
int main(){
scanf("%d%d",&n,&m);
int ans=max(n,m);
for(int i=1;i<=n;i++){
scanf("%s",s[i]+1);
top=0;sta[0]=1;
for(int j=2;j<=m+1;j++){
same[i][j]=(s[i-1][j]^s[i-1][j-1]^s[i][j]^s[i][j-1])==0 ? same[i-1][j]+1:1;
if(j==m+1) same[i][j]=0;
while(top>0&&same[i][sta[top]]>same[i][j]) ans=max(ans,(j-sta[top-1])*same[i][sta[top]]),top--;
sta[++top]=j;
}
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, w, h, f[2050];
long long fjc[200050], fjcinv[200050];
pair<int, int> a[2050];
inline int read() {
char c = getchar();
int f = 1;
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
int num = 0;
while (c >= '0' && c <= '9') {
num = (num << 1) + (num << 3) + (c ^ 48);
c = getchar();
}
return num * f;
}
long long power(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return ans;
}
int C(int a, int b) {
return fjc[a] * fjcinv[b] % 1000000007 * fjcinv[a - b] % 1000000007;
}
int main() {
fjc[0] = 1, fjcinv[0] = 1;
for (int i = 1; i <= 200000; i++) {
fjc[i] = fjc[i - 1] * i % 1000000007;
fjcinv[i] = power(fjc[i], 1000000007 - 2);
}
h = read(), w = read(), n = read();
for (int i = 1; i <= n; i++) a[i].first = read(), a[i].second = read();
sort(a + 1, a + 1 + n);
a[n + 1].first = h, a[n + 1].second = w;
for (int i = 1; i <= n + 1; i++) {
f[i] = C(a[i].first + a[i].second - 2, a[i].first - 1);
for (int j = 1; j < i; j++) {
if (a[j].first > a[i].first || a[j].second > a[i].second) continue;
f[i] = (f[i] - 1ll * f[j] *
C(a[i].first + a[i].second - a[j].first - a[j].second,
a[i].first - a[j].first)) %
1000000007;
}
}
printf("%d", (f[n + 1] + 1000000007) % 1000000007);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100000;
const int MOD =1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(){
COMinit();
int n,k,ans=0;
cin>>n>>k;
vector<int>a(n);
for(int i=0;i<n;i++){
cin>>a[i];
}
sort(a.begin(),a.end());
for(int i=0;i<n;i++){
ans=(ans+a[i]*(COM(i,k-1)-COM(n-i-1,k-1)))%MOD;
}
cout<<ans;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, par[5005];
vector<int> sz[5005];
string s[5005];
int f(int i) {
if (par[i] != i) par[i] = f(par[i]);
return par[i];
}
void merge(int a, int b) {
a = f(a), b = f(b);
if (a == b) return;
if (sz[a].size() < sz[b].size()) {
par[a] = b;
for (__typeof(sz[a].begin()) it = sz[a].begin(); it != sz[a].end(); it++)
sz[b].push_back(*it);
return;
}
par[b] = a;
for (__typeof(sz[b].begin()) it = sz[b].begin(); it != sz[b].end(); it++)
sz[a].push_back(*it);
}
vector<int> v[5005];
int d[5005];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i <= n - 1; i++) cin >> s[i];
for (int i = 1; i <= n + m; i++) par[i] = i;
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= m - 1; j++) {
if (s[i][j] == '=') merge(i + 1, n + j + 1);
}
}
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= m - 1; j++) {
int x = f(i + 1), y = f(n + j + 1);
if (s[i][j] == '<') {
if (x == y) {
cout << "No";
return 0;
}
v[x].push_back(y);
d[y]++;
} else if (s[i][j] == '>') {
if (x == y) {
cout << "No";
return 0;
}
v[y].push_back(x);
d[x]++;
}
}
}
int vis[5005] = {0}, ans[5005] = {0};
queue<int> q;
for (int i = 1; i <= n + m; i++) {
int x = f(i);
if (vis[x] == 0 && d[x] == 0) {
q.push(x);
vis[x] = 1;
ans[x] = 1;
}
}
while (!q.empty()) {
int at = q.front();
q.pop();
for (__typeof(v[at].begin()) it = v[at].begin(); it != v[at].end(); it++) {
int to = *it;
int tt = f(to);
d[tt]--;
if (d[tt] == 0) {
q.push(tt);
ans[tt] = ans[at] + 1;
}
}
}
for (int i = 1; i <= n + m; i++) {
if (d[i]) {
cout << "No";
return 0;
}
}
cout << "Yes\n";
for (int i = 1; i <= n; i++) {
cout << ans[f(i)];
cout << " ";
}
cout << "\n";
for (int i = 1; i <= m; i++) {
cout << ans[f(n + i)];
cout << " ";
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
const int MAX_N = 1<<17;
int n,dat[2*MAX_N-1];
void init(int n_){
n=1;
while(n<n_)n*=2;
for(int i=0;i<2*n-1;i++)dat[i]=INT_MAX;
}
void update(int k,int a){
k+=n-1;
dat[k]=a;
while(k>0){
k=(k-1)/2;
dat[k]=min(dat[k*2+1],dat[k*2+2]);
}
}
int query(int a,int b,int k,int l,int r){
if(r<=a||b<=l)return INT_MAX;
if(a<=l&&r<=b)return dat[k];
else{
int v1=query(a,b,k*2+1,l,(l+r)/2);
int vr=query(a,b,k*2+2,(l+r)/2,r);
return min(v1,vr);
}
}
int main(){
int q;
cin>>n>>q;
init(n);
for(int i=0,com,x,y;i<q;i++){
cin>>com>>x>>y;
if(com==0)update(x,y);
if(com==1)cout<<query(x,y+1,0,0,n)<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[105][105];
struct second {
int x, y, z, i, j, k;
void pr() {
cout << x + 1 << " " << y + 1 << " " << z + 1 << " " << i + 1 << " "
<< j + 1 << " " << k + 1 << "\n";
}
};
void tc() {
int n, m;
cin >> n >> m;
for (int i = 0; i < int(n); i++) {
string s;
cin >> s;
for (int j = 0; j < int(m); j++) {
a[i][j] = s[j] - '0';
}
}
vector<second> ans;
for (int i = 0; i < int(n - 1); i++)
for (int j = 0; j < int(m - 1); j++) {
int cnt = 0;
do {
cnt = 0;
for (int x : {i, i + 1}) {
for (int y : {j, j + 1}) {
if (a[x][y]) {
++cnt;
}
}
}
if (cnt == 1 || cnt == 2) {
int r = -1, c = -1;
for (int x : {i, i + 1}) {
for (int y : {j, j + 1}) {
if (a[x][y]) {
r = x, c = y;
}
}
}
int x1 = -1, y1 = -1, x2 = -1, y2 = -1;
if (r == i) {
x1 = i + 1, y1 = c;
} else {
x1 = i, y1 = c;
}
if (c == j) {
x2 = r, y2 = c + 1;
} else {
x2 = r, y2 = j;
}
ans.push_back(second{r, c, x1, y1, x2, y2});
a[r][c] ^= 1;
a[x1][y1] ^= 1;
a[x2][y2] ^= 1;
} else if (cnt == 3) {
int r = -1, c = -1, x1 = -1, y1 = -1, x2 = -1, y2 = -1;
for (int x : {i, i + 1}) {
for (int y : {j, j + 1}) {
if (a[x][y]) {
if (r == -1) {
r = x, c = y;
} else if (x1 == -1) {
x1 = x, y1 = y;
} else {
x2 = x, y2 = y;
}
}
}
}
ans.push_back(second{r, c, x1, y1, x2, y2});
a[r][c] = a[x1][y1] = a[x2][y2] = 0;
} else if (cnt == 4) {
ans.push_back(second{i, j, i + 1, j, i, j + 1});
a[i][j] = a[i + 1][j] = a[i][j + 1] = 0;
}
} while (cnt != 0);
}
cout << ans.size() << "\n";
for (auto& s : ans) {
s.pr();
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
tc();
}
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long ll;
void solve () {
int n;
cin >> n;
vector<ll> arr (n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr.begin(), arr.end());
ll prevsum = 0;
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += prevsum - (ll) i * arr[i];
prevsum += arr[i];
}
ans += arr.back();
cout << ans << '\n';
}
int main () {
ios::sync_with_stdio(false);
cin.tie(0);
int testc;
cin >> testc;
for (int i = 0; i < testc; i++) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int atas0[1010], atas1[1010], kiri0[1010], kiri1[1010];
long long ans;
int main() {
int i, j, x;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &x);
if (x) {
ans += kiri0[i];
kiri0[i] = 0;
ans += atas0[j];
atas0[j] = 0;
atas1[j]++;
kiri1[i]++;
} else {
if (kiri1[i] > 0) ans++;
if (atas1[j] > 0) ans++;
atas0[j]++;
kiri0[i]++;
}
}
}
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class C_ {};
template <typename T>
C_& operator<<(C_& __m, const T& __s) {
if (!1) cerr << "\E[91m" << __s << "\E[0m";
return __m;
}
C_ merr;
struct __s {
__s() {
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
merr << "Execution time: " << (double)clock() / CLOCKS_PER_SEC << " s.\n";
}
} __S;
string a, b;
bool bad(char c1, char c2) {
return (c1 == 'N' && c2 == 'S') || (c1 == 'S' && c2 == 'N') ||
(c1 == 'W' && c2 == 'E') || (c1 == 'E' && c2 == 'W');
}
int main(void) {
int idx1 = 0, idx2 = 0;
int cnt = 0;
int n;
cin >> n;
cin >> a >> b;
while ((idx1 < (int)a.size() || idx2 < (int)b.size()) && cnt < 5) {
while (idx1 < (int)a.size()) {
if (idx2 && bad(a[idx1], b[idx2 - 1])) {
idx2--;
} else if (idx2 < (int)b.size() && a[idx1] == b[idx2]) {
idx2++;
}
idx1++;
if (idx2 < (int)b.size() && !bad(b[idx2], a[idx1 - 1])) {
idx2++;
}
}
swap(idx1, idx2);
swap(a, b);
cnt++;
}
if (cnt >= 5) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[10001], n, i, j, c;
int main() {
cin >> n;
for (i = 2; i <= n; i++) {
if (a[i] == 0)
for (j = i; j <= n; j += i) a[j]++;
if (a[i] == 2) c++;
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char a[55][55];
struct Tpoint {
int x, y;
} p[55][55][4][2];
const int dir[4][2] = {{-1, 0}, {0, +1}, {+1, 0}, {0, -1}};
int main() {
int ss, n, m;
scanf("%d%d", &n, &ss);
for (int i = 0; i < n; i++) scanf("%s", a[i]);
m = strlen(a[0]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int d = 0; d < 4; d++)
for (int dd = 0; dd < 2; dd++) {
int x = i, y = j, xx, yy;
do {
xx = x + dir[d][0];
yy = y + dir[d][1];
if (xx < 0 || yy < 0 || xx >= n || yy >= m) break;
if (a[xx][yy] != a[x][y]) break;
x = xx;
y = yy;
} while (1);
int ddd;
if (dd == 0)
ddd = (d + 3) % 4;
else
ddd = (d + 1) % 4;
do {
xx = x + dir[ddd][0];
yy = y + dir[ddd][1];
if (xx < 0 || yy < 0 || xx >= n || yy >= m) break;
if (a[xx][yy] != a[x][y]) break;
x = xx;
y = yy;
} while (1);
p[i][j][d][dd].x = x;
p[i][j][d][dd].y = y;
}
int x = 0, y = 0, dp = 1, cp = 0;
while (ss--) {
int tx = p[x][y][dp][cp].x;
int ty = p[x][y][dp][cp].y;
x = tx;
y = ty;
tx += dir[dp][0];
ty += dir[dp][1];
if (tx < 0 || ty < 0 || tx >= n || ty >= m || a[tx][ty] == '0') {
if (cp == 0) {
cp = 1;
} else {
cp = 0;
dp = (dp + 1) % 4;
}
} else {
x = tx;
y = ty;
}
}
printf("%d\n", a[x][y] - '0');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> D(1000000);
vector<pair<long long int, long long int> > G[1000000];
set<long long int> A;
long long int findmin(long long int x) {
long long int temp = -1;
for (unsigned long long int i = 0; i < G[x].size(); i++) {
if (A.find(G[x][i].second) == A.end()) {
if (temp == -1 || temp > G[x][i].first) {
temp = G[x][i].first;
}
}
}
return temp;
}
using namespace std;
int main() {
long long int n, m, w, k, x, mini, temp, a, b;
cin >> n >> m >> k;
for (long long int i = 0; i < m; i++) {
cin >> a >> b >> w;
G[a].push_back(make_pair(w, b));
G[b].push_back(make_pair(w, a));
}
for (long long int i = 0; i < k; i++) {
cin >> x;
A.insert(x);
}
if (k == 0 || k == n) {
cout << "-1" << endl;
return 0;
}
set<long long int>::iterator it;
mini = -1;
for (it = A.begin(); it != A.end(); it++) {
temp = findmin(*it);
if (temp != -1)
if (mini == -1 || mini > temp) mini = temp;
}
cout << mini << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n <= 5) {
cout << "-1\n";
} else {
for (int i = 2; i <= 4; ++i) {
cout << "1 " << i << '\n';
}
for (int i = 5; i <= n; ++i) {
cout << "2 " << i << '\n';
}
}
for (int i = 1; i <= n - 1; ++i) {
cout << i << ' ' << i + 1 << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
const int INF = 2000000010;
int n, m, k;
int mi[maxn], ma[maxn], a[maxn], sum[maxn], v[maxn], la[maxn];
vector<pair<int, int>> G;
void add(int x, int cnt) {
for (int i = x; i <= max(n, m); i += (i & -i)) {
sum[i] += cnt;
}
}
int get_sum(int x) {
int ans = 0;
for (int i = x; i >= 1; i -= (i & -i)) {
ans += sum[i];
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) mi[i] = ma[i] = i;
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
if (!v[a[i]])
ma[a[i]] = max(ma[a[i]], a[i] + get_sum(n) - get_sum(a[i])), add(a[i], 1);
else
G.push_back(make_pair(v[a[i]], i));
la[i] = v[a[i]] + 1;
v[a[i]] = i;
mi[a[i]] = 1;
}
for (int i = 1; i <= n; i++) {
if (!v[i]) {
int x = get_sum(n) - get_sum(i);
ma[i] = max(ma[i], i + x);
}
}
for (int i = 1; i <= max(n, m); i++) sum[i] = 0;
k = 0;
for (int i = 0; i < (int)G.size(); i++) {
while (k < G[i].second) {
++k;
add(la[k], 1);
add(k + 1, -1);
}
int x = get_sum(G[i].first);
ma[a[G[i].first]] = max(ma[a[G[i].first]], x);
}
while (k < m) {
++k;
add(la[k], 1);
add(k + 1, -1);
}
for (int i = 1; i <= n; i++) {
if (v[i] > 0) {
int x = get_sum(v[i]);
ma[i] = max(ma[i], x);
}
}
for (int i = 1; i <= n; i++) {
printf("%d %d\n", mi[i], ma[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100005;
ifstream in("snacks.in");
ofstream out("snacks.out");
queue<int> q[nmax];
int snacks[nmax], sad = 0, n, k;
pair<int, int> g_prefs[nmax];
int guests[nmax];
void input() {
int i;
cin >> n >> k;
for (i = 1; i <= k; i++) {
cin >> g_prefs[i].first >> g_prefs[i].second;
q[g_prefs[i].first].push(i);
q[g_prefs[i].second].push(i);
}
for (i = 1; i <= n; i++) snacks[i] = 1;
}
queue<int> rec;
void hraneste(int i) {
int st, dr, new_st, new_dr, oaspete;
rec.push(i);
while (!rec.empty()) {
i = rec.front();
rec.pop();
guests[i] = 1;
st = g_prefs[i].first;
dr = g_prefs[i].second;
if (snacks[dr] == 0 && snacks[st] == 0) sad++;
snacks[st] = 0;
snacks[dr] = 0;
while (!q[st].empty()) {
oaspete = q[st].front();
new_st = g_prefs[q[st].front()].first;
new_dr = g_prefs[q[st].front()].second;
q[st].pop();
if (guests[oaspete] == 1) continue;
guests[oaspete] = 1;
if (snacks[new_st] == 0 && snacks[new_dr] == 0) {
sad++;
continue;
}
if (snacks[new_dr] == 0) swap(new_dr, new_st);
rec.push(oaspete);
}
while (!q[dr].empty()) {
oaspete = q[dr].front();
new_st = g_prefs[q[dr].front()].first;
new_dr = g_prefs[q[dr].front()].second;
guests[oaspete] = 1;
q[dr].pop();
if (snacks[new_st] == 0 && snacks[new_dr] == 0) {
continue;
}
if (snacks[new_dr] == 0) swap(new_dr, new_st);
rec.push(oaspete);
}
}
}
int main() {
int i, j, st, dr, new_st, new_dr, oaspete;
input();
for (i = 1; i <= k; i++) {
if (guests[i] == 0) {
hraneste(i);
}
}
cout << sad << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long fx[4] = {1, -1, 0, 0};
long long fy[4] = {0, 0, 1, -1};
int smallest(int x, int y, int z) {
int c = 0;
while (x && y && z) {
x--;
y--;
z--;
c++;
}
return c;
}
bool rs(long long a, long long b) { return (a > b); }
int main() {
long long n;
cin >> n;
vector<pair<long long, long long> > vp;
vector<long long> vec;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
vp.push_back(make_pair(x, i));
vec.push_back(x);
}
sort(vp.begin(), vp.end());
reverse(vp.begin(), vp.end());
long long maxi = 0;
for (long long i = 0; i < vp.size(); i++) {
long long c1 = 0, c2 = 0, ans;
if (vp[i].second != vec.size()) {
for (long long j = vp[i].second; j < vec.size() - 1; j++) {
if (vec[j] >= vec[j + 1])
c1++;
else
break;
}
}
if (vp[i].second != 1) {
for (long long j = vp[i].second; j > 0; j--) {
if (vec[j] >= vec[j - 1])
c2++;
else
break;
}
}
ans = c1 + c2;
maxi = max(maxi, ans);
}
cout << maxi + 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = n;
while (n > 1) {
int fac;
int flag = 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
fac = i;
flag = 1;
break;
}
}
if (flag == 0) fac = n;
ans = ans + (n / fac);
n = n / fac;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(){
int A, B, C;
cin >> A >> B;
C = A + B;
cout << (C % 24) << endl;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
const int maxn = 1e6;
const int maxN = 1e5 + 5;
const long long mod = 998244353;
using namespace std;
int n, m;
vector<int> adj[maxn];
bool vs[maxn];
int par[maxn];
pair<int, int> dfs(int u, int parr = -1, int w = 0) {
pair<int, int> ans;
ans = {w, u};
for (auto j : adj[u]) {
if (j == parr) continue;
par[j] = u;
ans = max(ans, dfs(j, u, w + 1));
}
return ans;
}
int main() {
if (fopen("A"
".inp",
"r")) {
freopen(
"A"
".inp",
"r", stdin);
}
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
pair<int, int> path1 = dfs(1);
pair<int, int> path2 = dfs(path1.second);
vector<int> diameter;
int cur_ver = path2.second;
while (cur_ver != path1.second) {
diameter.push_back(cur_ver);
cur_ver = par[cur_ver];
}
diameter.push_back(path1.second);
if ((int)diameter.size() == n) {
cout << n - 1 << "\n";
cout << path1.second << " " << path2.second << " ";
for (int i = 1; i <= n; i++) {
if (i != path1.second && i != path2.second) {
cout << i;
return 0;
}
}
} else {
queue<pair<int, int>> q;
for (int i = 1; i <= n; i++) vs[i] = true;
for (auto j : diameter) {
q.push({0, j});
vs[j] = false;
}
int goodver = path1.first;
int maxx = 0;
while (!q.empty()) {
int w = q.front().first;
int ver = q.front().second;
q.pop();
vs[ver] = false;
if (w > maxx) {
maxx = w;
goodver = ver;
}
for (auto j : adj[ver]) {
if (vs[j]) {
q.push({w + 1, j});
}
}
}
cout << (int)diameter.size() - 1 + maxx << "\n";
cout << path1.second << " " << path2.second << " " << goodver;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, mi, va;
int main() {
cin >> a >> b >> c >> d;
mi = max(3 * a / 10, a - a / 250 * c);
va = max(3 * b / 10, b - b / 250 * d);
if (mi > va) {
cout << "Misha";
} else if (va > mi) {
cout << "Vasya";
} else {
cout << "Tie";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, l, c, d, p, nl, np, a1, a2, a3, minele;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
a1 = (k * l) / nl;
a2 = c * d;
a3 = p / np;
minele = min(a1, a2);
minele = min(minele, a3);
cout << minele / n << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int i, j, k, l;
int main() {
char s[2222];
cin >> n >> s;
sort(s, s + n);
sort(s + n, s + n + n);
bool b1, b2;
b1 = b2 = true;
for (i = 0; i < n; ++i) {
b1 &= (s[i] > s[i + n]);
b2 &= (s[i] < s[i + n]);
}
cout << ((b1 | b2) ? "YES" : "NO") << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 110;
int n, m;
int a[MAX] = {0};
void clear() {}
bool cmp(const int &a, const int &b) { return a > b; }
void solve() {
scanf("%d", &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n, cmp);
int r = 0;
while (m > 0) {
m -= a[r++];
}
printf("%d\n", r);
}
int main() {
while (scanf("%d", &n) == 1) {
clear();
solve();
return 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long binexp(long long a, long long b, long long m) {
a %= m;
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
a = (a * a) % m;
b >>= 1;
}
return (ans % m);
}
int32_t solve(long long _, long long _t) {
long long n, k;
cin >> n >> k;
vector<long long> v;
set<long long> s;
for (long long i = 0; i < (long long)n; i++) {
long long x;
cin >> x;
v.push_back(x);
s.insert(x);
}
if (k == 1 && s.size() != 1) return cout << -1 << '\n', 0;
if (s.size() <= k) {
cout << 1 << '\n';
return 0;
}
long long ans = 1;
vector<long long> t;
for (auto i : s) {
t.push_back(i);
}
s.clear();
for (long long i = 0; i < t.size(); i++) {
if (s.size() == k) {
s.clear();
s.insert(0);
ans++;
}
s.insert(t[i]);
}
cout << ans << '\n';
return 0;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
long long _ = 1;
cin >> _;
long long _t = _;
while (_--) solve(_, _t);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, i, j, k, x, y, z, l, r, mid, ans, mod = 1e9 + 7, g, m;
long long a[400005], b[400005], c[400005];
char ch;
string s, st;
vector<long long> v[300004], u;
int main() {
ios::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> l >> r >> x >> y;
if (l > x)
cout << r << " " << x << "\n";
else
cout << l << " " << y << "\n";
}
}
| 1 |
#include <cstdio>
#include <cmath>
int main(){
int a=100000,n;
scanf("%d",&n);
while(n--){
int b=a/20;
a+=b-b%1000;
if(b%1000!=0)
a+=1000;
}
printf("%d\n",a);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int rt, K, n, cnt, typ;
vector<int> linker[2005];
void dfs(int x, int fa, int ndep)
{
if (ndep > ((K - typ) >> 1)) ++ cnt;
for (int cur : linker[x])
if (cur != fa) dfs(cur, x, ndep + 1);
}
int main()
{
scanf("%d %d", &n, &K);
for (int i = 1; i < n; i ++)
{
int u, v; scanf("%d %d", &u, &v);
linker[u].push_back(v), linker[v].push_back(u);
}
int ans = n; typ = 0;
for (rt = 1; rt <= n; rt ++)
{
cnt = 0, dfs(rt, 0, 0);
ans = min(ans, cnt);
}
typ = 1;
for (rt = 1; rt <= n; rt ++)
{
for (auto rt2 : linker[rt])
{
cnt = 0;
dfs(rt, rt2, 0), dfs(rt2, rt, 0);
ans = min(ans, cnt);
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n;
int a, b, c, d;
int main() {
while (~scanf("%d", &n)) {
int ok = -1;
int ans1, ans2;
for (int i = 0; i < 4; ++i) {
scanf("%d%d%d%d", &a, &b, &c, &d);
if (ok == -1) {
if (a + c <= n || a + d <= n || b + c <= n || b + d <= n) {
ok = i + 1;
if (a + c <= n || a + d <= n) {
ans1 = a;
ans2 = n - a;
} else {
ans1 = b;
ans2 = n - b;
}
}
}
}
if (ok != -1) {
printf("%d %d %d\n", ok, ans1, ans2);
} else
printf("-1\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, s;
cin >> n >> m >> k >> s;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i], --a[i];
vector<vector<int>> dp(n, vector<int>(k, 100000000));
vector<vector<int>> adj(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 0; i < k; i++) {
queue<int> q;
for (int j = 0; j < n; j++)
if (a[j] == i) dp[j][i] = 0, q.push(j);
while (!q.empty()) {
auto curr = q.front();
q.pop();
for (int next : adj[curr]) {
if (dp[curr][i] + 1 < dp[next][i])
q.push(next), dp[next][i] = dp[curr][i] + 1;
}
}
}
for (int j = 0; j < n; j++) {
sort(dp[j].begin(), dp[j].end());
int ans = 0;
for (int x = 0; x < s; x++) ans += dp[j][x];
cout << ans << " ";
}
cout << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using PII = pair<int, int>;
using PLL = pair<long long, long long>;
using VLL = vector<long long>;
using VI = vector<int>;
inline void fastio() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fL;
const int mod1 = 998244353;
const int mod2 = 1e9 + 7;
void solve() {
int n, m, k;
cin >> n >> m >> k;
if (k <= 1) {
cout << "NO" << endl;
return;
}
if (m < n - 1) {
cout << "NO" << endl;
return;
}
long long cnt = 1ll * n * (n - 1) / 2;
if (m > cnt) {
cout << "NO" << endl;
return;
}
if (k == 2 && n > 1) {
cout << "NO" << endl;
return;
}
if (k >= 2 && n == 1) {
cout << "YES" << endl;
return;
}
if (k > 3) {
cout << "YES" << endl;
return;
}
if (m == cnt) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
signed main() {
fastio();
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
long long int read_int() {
char r;
bool start = false, neg = false;
long long int ret = 0;
while (true) {
r = getchar();
if ((r - '0' < 0 || r - '0' > 9) && r != '-' && !start) {
continue;
}
if ((r - '0' < 0 || r - '0' > 9) && r != '-' && start) {
break;
}
if (start) ret *= 10;
start = true;
if (r == '-')
neg = true;
else
ret += r - '0';
}
if (!neg)
return ret;
else
return -ret;
}
int main() {
map<long long, long long> x;
map<long long, long long> y;
map<pair<long long, long long>, long long> z;
long long n, a, b, ans = 0;
n = read_int();
while (n--) {
a = read_int();
b = read_int();
ans += (x[a]++);
ans += (y[b]++);
ans -= z[make_pair(a, b)]++;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 7;
const int M = 100000 + 2;
const int inf = 1e9 + 7;
const long long linf = 1ll * inf * inf + 7;
const double pi = acos(-1);
const double eps = 1e-8;
const bool multipleTest = 0;
int n;
int a[N];
int dp[N][126][270];
int pre[N][10];
int last[10];
void solve() {
memset(dp, -inf, sizeof(dp));
for (int mask = (0); mask < (1 << 8); mask++) dp[0][0][mask] = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
int u;
scanf("%d", &u);
--u;
a[i] = u;
for (int j = 0; j < 8; ++j) pre[i][j] = last[j];
last[u] = i;
}
for (int i = 1; i <= n; ++i) {
for (int mask = (0); mask < (1 << 8); mask++) {
if (!(mask & (1 << a[i]))) {
for (int len = (0); len < (126); len++)
dp[i][len][mask] = dp[i - 1][len][mask];
} else {
for (int len = (0); len < (126); len++)
dp[i][len][mask] = dp[i - 1][len][mask];
int other = mask ^ (1 << a[i]);
for (int len = 1, cur = i; len <= 125 && cur > 0;
++len, cur = pre[cur][a[i]]) {
dp[i][len][mask] =
max(dp[i][len][mask], dp[cur - 1][len][other] + len);
dp[i][len - 1][mask] =
max(dp[i][len - 1][mask], dp[cur - 1][len - 1][other] + len);
}
}
int curMask = 1 << a[i];
for (int len = 1, cur = i; len <= 125 && cur > 0;
++len, cur = pre[cur][a[i]]) {
dp[i][len][curMask] = max(dp[i][len][curMask], len);
dp[i][len - 1][curMask] = max(dp[i][len - 1][curMask], len);
}
}
}
int ans = 0;
for (int len = (0); len < (126); len++) {
ans = max(ans, dp[n][len][(1 << 8) - 1]);
}
cout << ans << '\n';
}
void createTest() {
freopen("in.txt", "w", stdout);
int n = 500000;
cout << n << "\n";
for (int i = 1; i < n; ++i) {
int u = i;
char c = (rand() % 22) + 'a';
printf("%d %c\n", u, c);
}
}
int main() {
if (fopen("bishops.in", "r")) {
freopen("bishops.in", "r", stdin);
}
int Test = 1;
if (multipleTest) {
cin >> Test;
}
for (int i = 0; i < Test; ++i) {
solve();
}
}
| 5 |
/* template.cpp {{{ */
#include <bits/stdc++.h>
using namespace std;
#define get_macro(a, b, c, d, name, ...) name
#define rep(...) get_macro(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep(...) get_macro(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)
#define rep1(n) rep2(i_, n)
#define rep2(i, n) rep3(i, 0, n)
#define rep3(i, a, b) rep4(i, a, b, 1)
#define rep4(i, a, b, s) for (ll i = (a); i < (ll)(b); i += (ll)(s))
#define rrep1(n) rrep2(i_, n)
#define rrep2(i, n) rrep3(i, 0, n)
#define rrep3(i, a, b) rrep4(i, a, b, 1)
#define rrep4(i, a, b, s) for (ll i = (ll)(b) - 1; i >= (ll)(a); i -= (ll)(s))
#define each(x, c) for (auto &&x : c)
#define fs first
#define sc second
#define all(c) begin(c), end(c)
using ui = unsigned;
using ll = long long;
using ul = unsigned long long;
using ld = long double;
const int inf = 1e9 + 10;
const ll inf_ll = 1e18 + 10;
const ll mod = 1e9 + 7;
const ll mod9 = 1e9 + 9;
const int dx[]{-1, 0, 1, 0, -1, 1, 1, -1};
const int dy[]{0, -1, 0, 1, -1, -1, 1, 1};
template<class T, class U> void chmin(T &x, const U &y){ x = min<T>(x, y); }
template<class T, class U> void chmax(T &x, const U &y){ x = max<T>(x, y); }
struct prepare_ { prepare_(){ cin.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(12); } } prepare__;
/* }}} */
int main(){
string s, t = "0123456789";
cin >> s;
pair<ll, string> res;
ll tn = 1;
rep(s.size()) tn *= 10;
do {
ll a = stoll(s);
ll b = stoll(t.substr(0, s.size()));
//cout << t << endl;
chmin(res, make_pair(-min(abs(a - b), tn - abs(a - b)), t.substr(0, s.size())));
} while (next_permutation(all(t)));
cout << res.second << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long len, d;
cin >> len >> d;
string s;
cin >> s;
long long j = 1;
long long count = 0;
long long i = 0;
long long point = -1;
while (1) {
if (i < d && j < len) {
if (s[j] == '1') point = j;
i++;
j++;
} else if (i == d) {
if (point == -1) {
cout << -1 << "\n";
return 0;
} else {
count++;
j = point + 1;
point = -1;
i = 0;
}
} else
break;
}
if (point != -1) count++;
cout << count << "\n";
return 0;
}
| 1 |
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#define MOD 1000000007
using namespace std;
int n, m, k;
int quickPow(int n, int m) {
int res = 1;
while (m) {
if (m & 1) res = 1LL * res * n % MOD;
m >>= 1;
n = 1LL * n * n % MOD;
}
return res;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
if (m > k) swap(m, k);
int ans = quickPow(3, m + k), tmp1 = 1, tmp2 = 1;
for (int p = n + 1, e, u = 1, v = 1; p <= n + m + k; ++p) {
e = quickPow(3, n + m + k - p);
v = 1LL * v * (p - 1) % MOD * quickPow(p - n, MOD - 2) % MOD;
if (p <= n + m) u = u * 2 % MOD;
else if (p <= n + k) {
tmp1 = p - n - 1 == m ? 1 : 1LL * tmp1 * (p - n - 1) % MOD * quickPow(p - n - m - 1, MOD - 2) % MOD;
u = (2LL * u - tmp1 + MOD) % MOD;
}
else {
tmp1 = p - n - 1 == m ? 1 : 1LL * tmp1 * (p - n - 1) % MOD * quickPow(p - n - m - 1, MOD - 2) % MOD;
tmp2 = p == (1 + n + k) ? 1 : 1LL * tmp2 * (p - 1 - n) % MOD * quickPow(p - n - 1 - k, MOD - 2) % MOD;
u = (2LL * u - tmp1 - tmp2 + MOD + MOD) % MOD;
}
ans = (ans + 1LL * e * v % MOD * u % MOD) % MOD;
}
printf("%d\n", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 0x3f3f3f3f;
int n, k, a[35001], dp[35001][55];
int tree[55][176000], ever[55][176000];
int put(int k, int a, int b, int l, int r, int id, int val) {
if (r <= a || l >= b) {
return tree[id][k] + ever[id][k];
}
if (r <= b && l >= a) {
ever[id][k] += val;
return tree[id][k] + ever[id][k];
}
int mid = (l + r) >> 1;
return (tree[id][k] = max(put(k * 2, a, b, l, mid, id, val),
put(k * 2 + 1, a, b, mid, r, id, val))) +
ever[id][k];
}
int find(int k, int a, int b, int l, int r, int id) {
if (r <= a || l >= b) return 0;
if (r <= b && l >= a) {
return ever[id][k] + tree[id][k];
}
int mid = (l + r) >> 1;
return max(find(k * 2, a, b, l, mid, id), find(k * 2 + 1, a, b, mid, r, id)) +
ever[id][k];
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i <= n - 1; i++) scanf("%d", &a[i]);
int pre[35001], last[35001];
memset(last, 0, sizeof(last));
map<int, int> m;
int tohere[35001] = {0};
for (int i = 0; i <= n - 1; i++) {
tohere[i] = tohere[max(0, i - 1)];
if (!m[a[i]]) {
m[a[i]] = 1;
tohere[i]++;
}
pre[i] = last[a[i]];
last[a[i]] = i;
}
int startn = n;
n = 1 << int(ceil(log2(double(n))));
for (int i = 0; i <= startn - 1; i++) {
for (int j = 1; j <= k; j++) {
put(1, pre[i], i, 0, n, j - 1, 1);
if (i == 0) {
dp[i][j] = 1;
} else {
if (j == 1)
dp[i][j] = tohere[i];
else
dp[i][j] = find(1, 0, i, 0, n, j - 1);
}
put(1, i, i + 1, 0, n, j, dp[i][j]);
}
}
printf("%d\n", dp[startn - 1][k]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MSIZE = 3e5;
const long long base = 7;
const double EPS = 1e-9;
vector<long long> fac;
vector<long long> ifac;
long long gcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long inum(long long a) {
long long x, y;
long long g = gcd(a, MOD, x, y);
x = (x % MOD + MOD) % MOD;
return x;
}
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
fac.push_back(1);
ifac.push_back(1);
for (int i = 1; i <= n; ++i) {
fac.push_back((fac[i - 1] * i) % MOD);
ifac.push_back(inum(fac.back()));
}
vector<long long> d(n + 1);
vector<long long> pref(n + 1);
for (int i = 1; i <= n; ++i) {
if (k >= i) {
d[i] = 0;
pref[i] = 0;
} else {
d[i] = ((i - k - 1) * fac[i - 2] % MOD +
fac[i - 2] * (pref[i - 1] - pref[i - k - 1] + MOD)) %
MOD;
pref[i] = (pref[i - 1] + d[i] * ifac[i - 1]) % MOD;
}
}
cout << (pref[n] * fac[n - 1]) % MOD;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ar[100006];
long long cnt[100004];
int main() {
long long n;
cin >> n;
long long m = 1;
if (n % 2 == 0) m = 2;
long long mid = (n + 1) / 2;
long long k = 1;
long long mx = -1;
for (long long i = 1; i <= n; i++) {
cin >> ar[i];
long long df = ar[i] - k;
if (df >= 0) cnt[df]++;
if (i == mid) {
if (m == 1) k--;
m--;
} else if (i > mid)
k--;
else
k++;
}
for (long long i = 0; i <= 100000; i++) {
if (mx < cnt[i]) mx = cnt[i];
}
cout << (n - mx) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 155;
int n, k;
int s;
int a[MN];
int dp[MN][MN * MN];
int main() {
for (int i = 0; i < MN; i++) {
for (int j = 0; j < MN * MN; j++) {
dp[i][j] = 1e9;
}
}
cin >> n >> k >> s;
s += (k - 1) * k / 2;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
s = min(s, (n - 1) * n / 2);
for (int i = 0; i <= s; i++) {
dp[0][i] = 0;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = k; j >= 1; j--) {
for (int l = 0; l <= (i - 1) * i / 2; l++) {
dp[j][l] = min(dp[j - 1][l + i] + a[i], dp[j][l]);
}
}
}
printf("%d\n", dp[k][0]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50005;
const int inf = 1000000000;
const int B = 8;
int n, bin[10], cnt, last[N], anc[N], fa[N], ans[N][256], dp[256][10], dep[N],
a[N], q;
struct edge {
int to, next;
} e[N * 2];
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void addedge(int u, int v) {
e[++cnt].to = v;
e[cnt].next = last[u];
last[u] = cnt;
e[++cnt].to = u;
e[cnt].next = last[v];
last[v] = cnt;
}
void dfs(int x) {
dep[x] = dep[fa[x]] + 1;
for (int i = last[x]; i; i = e[i].next)
if (e[i].to != fa[x]) fa[e[i].to] = x, dfs(e[i].to);
if (dep[x] < bin[B]) return;
anc[x] = x;
for (int i = 0; i < bin[B]; i++) dp[i][0] = -inf, anc[x] = fa[anc[x]];
for (int i = 0, y = x; i < bin[B]; i++, y = fa[y])
dp[a[y] >> B][0] =
max(dp[a[y] >> B][0], ((dep[x] - dep[y]) ^ a[y]) & (bin[B] - 1));
for (int j = 1; j <= B; j++)
for (int i = 0; i < bin[B]; i++)
dp[i][j] =
max(dp[i][j - 1], dp[i ^ bin[j - 1]][j - 1] + bin[j - 1] * bin[B]);
for (int i = 0; i < bin[B]; i++) ans[x][i] = dp[i][B];
}
int main() {
bin[0] = 1;
for (int i = 1; i <= 8; i++) bin[i] = bin[i - 1] * 2;
n = read();
q = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read();
addedge(x, y);
}
dfs(1);
while (q--) {
int u = read(), v = read(), x = v, mx = 0, d = 0;
while (dep[anc[x]] >= dep[u]) mx = max(mx, ans[x][d]), d++, x = anc[x];
while (dep[x] >= dep[u]) mx = max(mx, (dep[v] - dep[x]) ^ a[x]), x = fa[x];
printf("%d\n", mx);
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
static const int64_t mod=1000000007;
int64_t f(int64_t x,int64_t y){
if(y==0)
return 1;
else if(y%2==0)
return (f(x,y/2)*f(x,y/2))%mod;
else
return (f(x,y/2)*((x*f(x,y/2))%mod))%mod;
}
int64_t comb(int64_t x,int64_t y){
int64_t ans=1;
for(int64_t i=y;1<=i;i--){
ans=(f(i,mod-2)*((ans*(x-y+i))%mod))%mod;
}return ans;
}
int main(){
int64_t N,M;
cin>>N>>M;
int64_t m=M;
vector<int64_t>A={};
for(int64_t i=2;i*i<=m;i++){
if(M%i==0){
int64_t a=0;
while(M%i==0){
M/=i; a++;
}A.push_back(a);
}
}if(M!=1)
A.push_back(1);
int L=A.size();
int64_t ans=1;
for(int i=0;i<L;i++){
int64_t a=A.at(i);
ans=(ans*comb(N-1+a,a))%mod;
}cout<<ans<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define LL long long
#define maxn 100005
using namespace std;
int a[maxn];
void solve(int n)
{
int mx=0,mn=n;
for(int i=1;i<=n;i++)
{
mx=max(mx,a[i]);
mn=min(mn,a[i]);
}
if(mx-mn>=2)
{
puts("No");
return ;
}
if(mx==mn)
{
if(mx==n-1) puts("Yes");
else if(mx*2<=n) puts("Yes");
else puts("No");
return ;
}
int cnt=0;
for(int i=1;i<=n;i++)
if(a[i]==mn) cnt++;
if(cnt<mx&&2*(mx-cnt)+cnt<=n)
{
puts("Yes");
return ;
}
puts("No");
return ;
}
int main()
{
int n;
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
solve(n);
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef vector<int> vi;
#define PB push_back
#define rep(i,x) for(int i=0;i<(x);++i)
#define rep1(i,x) for(int i=1;i<=(x);++i)
#define all(a) a.begin(),a.end()
int P[1001];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
while (cin >> N >> M, N || M) {
rep1(i, N) cin >> P[i];
vi A;
rep(i, N + 1) rep(j, i + 1) if (P[i] + P[j] <= M) A.PB(P[i] + P[j]);
sort(all(A));
int ma = 0;
int l = 0, r = A.size() - 1;
while (l <= r) {
while (A[l] + A[r] > M) r--;
ma = max(ma, A[l] + A[r]);
l++;
}
cout << ma << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void _print(long long 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 power(long long x, long long n) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % 1000000007;
x = (x * x) % 1000000007;
n = n / 2;
}
return result % 1000000007;
}
template <class T>
T gcd(T a, T b) {
while (a != 0) {
T temp = a;
a = b % a;
b = temp;
}
return b;
}
bool compare(long long a, long long b) { return a >= b; }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a;
cin >> a;
vector<long long> vec(2 * a, 0);
bool z = 1;
if (a % 2 == 0) z = 0;
if (z) {
long long j = 0;
for (long long i = 0; i < a; i++) {
if (i % 2 == 0) {
vec[i] = j + 1;
vec[a + i] = j + 2;
} else {
vec[i] = j + 2;
vec[a + i] = j + 1;
}
j = j + 2;
}
}
if (z) {
cout << "YES"
<< "\n";
for (long long i = 0; i < 2 * a; i++) cout << vec[i] << " ";
cout << "\n";
} else
cout << "NO"
<< "\n";
}
| 1 |
#include <iostream>
using namespace std;
int main() {
int d,i,s;
while (cin >> d) {
s=0;
for (i=d;i<600;i+=d) s+=d*i*i;
cout << s << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long LINF = 1LL * INF * INF;
const int MAX = 100010;
const long double PI = acos(-1.);
const double EPS = 1e-6;
long long mod = 1000LL * 1000 * 1000 + 7;
int n, v;
int cnt[104];
int a[300005];
int pr[300005];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (i) pr[i] = pr[i - 1];
pr[i] ^= a[i];
}
map<int, int> foo1;
map<int, int> foo2;
for (int i = 0; i < n; ++i) {
if (i % 2) {
foo1[pr[i]]++;
} else {
foo2[pr[i]]++;
}
}
foo1[0]++;
long long ans = 0;
for (auto& iter : foo1) {
ans += 1LL * (iter.second - 1) * iter.second;
}
for (auto& iter : foo2) {
ans += 1LL * (iter.second - 1) * iter.second;
}
cout << ans / 2;
cin >> n;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int v[1505][1505];
long long mem[1505][1505];
const long long OO = 1LL * 1500 * 1500 * 20000 + 5;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &v[i][j]);
for (int i = 0; i < n; i++)
for (int j = 1; j < m; j++) v[i][j] += v[i][j - 1];
for (int i = n - 1; i >= 0; i--) {
if (i % 2 == 0) {
mem[i][m - 1] = -OO;
mem[i][m - 2] = v[i][m - 1] + (i == n - 1 ? 0 : mem[i + 1][m - 1]);
for (int lst = m - 3; lst >= 0; lst--)
mem[i][lst] =
max(mem[i][lst + 1],
v[i][lst + 1] + (i == n - 1 ? 0 : mem[i + 1][lst + 1]));
} else {
mem[i][0] = -OO;
mem[i][1] = v[i][0] + (i == n - 1 ? 0 : mem[i + 1][0]);
for (int lst = 2; lst < m; lst++)
mem[i][lst] =
max(mem[i][lst - 1],
v[i][lst - 1] + (i == n - 1 ? 0 : mem[i + 1][lst - 1]));
}
}
cout << mem[0][0];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long mod = 998244353, invg = 332748118;
long long fp[N], fac[N], inv[N];
inline long long power(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) res = res * a % mod;
return res;
}
inline long long C(int a, int b) {
return fac[a] * inv[b] % mod * inv[a - b] % mod;
}
int main() {
int n;
long long res, ans = 0;
scanf("%d", &n);
fp[0] = 1;
for (int i = 1; i <= n; i++) fp[i] = fp[i - 1] * 3 % mod;
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
inv[n] = power(fac[n], mod - 2);
for (int i = n - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
res = power(3, 1ll * n * n);
for (int i = 1; i <= n; i++) {
long long sum = C(n, i) * power(invg, 1ll * n * i) % mod *
(power((1 - power(invg, n - i) + mod) % mod, n) - 1 + mod) %
mod;
ans = (i & 1 ? ans - sum + mod : ans + sum) % mod;
}
ans = ans * res % mod * 3 % mod;
for (int i = 1; i <= n; i++) {
long long sum =
C(n, i) * fp[i] % mod * power(3, 1ll * (n - i) * n) % mod * 2 % mod;
ans = (i & 1 ? ans - sum + mod : ans + sum) % mod;
}
ans = (ans + res) % mod;
printf("%lld\n", (res - ans + mod) % mod);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int main() {
int n, x, m;
cin >> n >> m;
while (n--) {
cin >> x;
a.push_back(x);
}
sort(a.begin(), a.end());
while (m--) {
cin >> x;
cout << upper_bound(a.begin(), a.end(), x) - a.begin() << endl;
}
}
| 2 |
#include <bits/stdc++.h>
long long s[100001];
long long b[100001];
long long a[200000];
int p(long long n, long long k) {
if (k == 0) return 1;
long long h = p(n, k >> 1);
if (k & 1)
return (((h * h) % 1000000007) * n) % 1000000007;
else
return (h * h) % 1000000007;
}
int main() {
long long n, i, r = 0;
s[0] = 1;
scanf("%I64d", &n);
for (i = 0; i < n; i++) scanf("%I64d", &(a[i]));
for (i = 1; i < 100001; i++) s[i] = (s[i - 1] * i) % 1000000007;
if (n % 4 == 0) {
for (i = 0; i < n / 2; i++) {
b[i] = (s[n / 2 - 1] *
(p((s[i] * s[n / 2 - 1 - i]) % 1000000007, 1000000007 - 2))) %
1000000007;
}
for (i = 0; i < n; i++) {
if (i % 2 == 0)
r = (r + b[i / 2] * a[i]) % 1000000007;
else
r = (r + (1000000007 - b[i / 2]) * a[i]) % 1000000007;
}
} else if (n % 4 == 1) {
for (i = 0; i <= n / 2; i++) {
b[i] =
(s[n / 2] * (p((s[i] * s[n / 2 - i]) % 1000000007, 1000000007 - 2))) %
1000000007;
}
for (i = 0; i < n; i++) {
if (i % 2 == 0) r = (r + b[i / 2] * a[i]) % 1000000007;
}
} else if (n % 4 == 2) {
for (i = 0; i < n / 2; i++) {
b[i] = (s[n / 2 - 1] *
(p((s[i] * s[n / 2 - 1 - i]) % 1000000007, 1000000007 - 2))) %
1000000007;
}
for (i = 0; i < n; i++) {
r = (r + b[i / 2] * a[i]) % 1000000007;
}
} else {
for (i = 0; i < n / 2; i++) {
b[i] = (s[n / 2 - 1] *
(p((s[i] * s[n / 2 - 1 - i]) % 1000000007, 1000000007 - 2))) %
1000000007;
}
for (i = 0; i < n; i++) {
if (i % 2 == 1)
r = (r + ((2 * b[i / 2]) % 1000000007) * a[i]) % 1000000007;
else {
if (i == 0)
r = (r + a[i]) % 1000000007;
else if (i == n - 1)
r = (r + (1000000007 - 1) * a[i]) % 1000000007;
else
r = (r + (1000000007 + b[i / 2] - b[i / 2 - 1]) * a[i]) % 1000000007;
}
}
}
printf("%I64d", r);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a;
long long x, y;
while (cin >> n >> m >> a) {
if (n / a == n / (double)a)
x = n / a;
else
x = (int)(n / (double)a) + 1;
if (m / a == m / (double)a)
y = m / a;
else
y = (int)(m / (double)a) + 1;
cout << x * y << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, inf = 1e9 + 7, mod = 1e9 + 7;
const long double eps = 1e-12;
const long long linf = (long long)1e18 + 7;
long long n, m, x, y, a[N], b[N], cnt;
vector<long long> g[N];
map<int, bool> q;
bool ok = 0;
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if ((int)(g[i]).size() < n - 1) {
ok = 1;
for (int j = 0; j < (int)(g[i]).size(); j++) {
q[g[i][j]] = 1;
}
for (int j = 1; j <= n; j++) {
if (!q[j] && j != i) {
a[i] = b[i] = b[j] = n;
a[j] = n - 1;
break;
}
}
break;
}
}
if (!ok) {
cout << "NO";
return 0;
}
cout << "YES\n";
for (int i = 1; i <= n; i++) {
if (a[i] == 0) {
a[i] = b[i] = ++cnt;
}
}
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
cout << "\n";
for (int i = 1; i <= n; i++) {
cout << b[i] << " ";
}
}
| 4 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <string.h>
typedef long long ll;
#define MAX(x, y) (((x) > (y))? (x) : (y))
#define MIN(x, y) (((x) < (y))? (x) : (y))
#define ABS(x) (((x) < 0)? (-1*(x)) : (x))
#define REPI(x,y) for (int i=(x);i<(y);i++)
#define REPJ(x,y) for (int j=(x);j<(y);j++)
#define MEMCLR(X) memset((X),0,sizeof((X)))
using namespace std;
typedef vector<vector<pair<int, int>>> GRA;
int i,j,N,K,ma,mi=1000000,mai,mii;
int main() {
cin >> N;
vector<int> A(N);
REPI(0,N) {
cin >> A[i];
if (A[i]>ma) {
ma = A[i];
mai = i;
} else if (A[i]<mi) {
mi = A[i];
mii = i;
}
}
cout << (2*N-1) << endl;
REPI(1,N+1) {
if (ABS(ma)>=ABS(mi)) cout << (mai+1) << " " << i << endl;
else cout << (mii+1) << " " << i << endl;
}
REPI(0,N-1) {
if (ABS(ma)>=ABS(mi)) cout << (i+1) << " " << i+2 << endl;
else cout << (N-i) << " " << (N-i-1) << endl;
}
return 0;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.