solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, cnt = 1;
int main() {
cin >> n;
while (cnt * 2 <= n) cnt *= 2;
if (n % 2) return cout << (n - 1) / 2, 0;
cout << (n - cnt) / 2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MODULO = 1000003;
const int NMAX = 700005;
int n, C, comb[NMAX], fact[NMAX], factinv[NMAX];
int sol;
int Log(int x, int y) {
int p = 1;
while (y) {
if (y & 1) p = (1LL * p * x) % MODULO;
x = (1LL * x * x) % MODULO;
y >>= 1;
}
return p;
}
int Com(int x, int y) {
int aux = (1LL * fact[x] * factinv[y]) % MODULO;
aux = (1LL * aux * factinv[x - y]) % MODULO;
return aux;
}
int main() {
int i;
cin.sync_with_stdio(false);
cin >> n >> C;
fact[0] = fact[1] = 1;
for (i = 2; i < NMAX; i++) fact[i] = (1LL * fact[i - 1] * i) % MODULO;
factinv[NMAX - 1] = Log(fact[NMAX - 1], MODULO - 2);
for (i = NMAX - 2; i >= 0; i--)
factinv[i] = (1LL * factinv[i + 1] * (i + 1)) % MODULO;
for (i = 1; i <= n; i++) {
sol += Com(i + C - 1, C - 1);
if (sol >= MODULO) sol -= MODULO;
}
cout << sol << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edges[300005], vis(300005), ans(300005);
vector<set<int> > color(300005);
void bfs(int i) {
queue<int> q;
q.push(0);
while (!q.empty()) {
int clr = 1;
int u = q.front();
q.pop();
set<int> st;
vis[u] = 1;
for (auto i : color[u]) {
if (ans[i]) st.insert(ans[i]);
}
for (auto i : color[u]) {
if (ans[i] == 0) {
while (st.find(clr) != st.end()) clr++;
st.insert(clr);
ans[i] = clr;
}
}
for (auto i : edges[u]) {
if (vis[i] == 0) {
q.push(i);
}
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
while (x--) {
int c;
scanf("%d", &c);
color[i].insert(c);
}
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
edges[u].push_back(v);
edges[v].push_back(u);
}
bfs(0);
set<int> s;
for (int i = 1; i <= m; i++) {
s.insert(max(ans[i], 1));
}
printf("%d \n", s.size());
for (int i = 1; i <= m; i++) printf("%d ", max(ans[i], 1));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class CDiscreteAcceleration {
public:
void solveOne(std::istream &in, std::ostream &out) {
int n;
in >> n;
double l;
in >> l;
double a[n];
for (int i = 0; i < n; ++i) in >> a[i];
double lpos = 0, rpos = l, ls = 1, rs = 1, t = 0;
int lp = 0, rp = n - 1;
while (lp <= rp) {
double ld = a[lp] - lpos, rd = rpos - a[rp], lt = ld / ls, rt = rd / rs;
if (lt < rt) {
lpos = a[lp];
t += lt;
rpos -= rs * lt;
ls++;
lp++;
} else {
rpos = a[rp];
t += rt;
lpos += ls * rt;
rs++;
rp--;
}
}
t += (rpos - lpos) / (ls + rs);
out << t << endl;
}
void solve(std::istream &in, std::ostream &out) {
ios_base::sync_with_stdio(false);
in.tie();
out.tie();
int t = 1;
in >> t;
out.precision(12);
while (t--) {
solveOne(in, out);
}
}
};
int main() {
CDiscreteAcceleration solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int T;
int a, b, c;
int main() {
cin >> T;
while (T--) {
cin >> a >> b >> c;
if (a < b) swap(a, b);
if (a < c) swap(a, c);
if (b < c) swap(b, c);
int ans = 0;
if (a) ans++, a--;
if (b) ans++, b--;
if (c) ans++, c--;
if (a && b) ans++, a--, b--;
if (a && c) ans++, a--, c--;
if (b && c) ans++, b--, c--;
if (a && b && c) ans++, a--, b--, c--;
cout << ans << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long faktori[30][65];
long long djelitelji[2][30];
int main() {
long long n, b;
cin >> n >> b;
int brd = 0;
for (long long i = 2; i * i <= b; i++) {
if (b % i == 0) {
djelitelji[0][brd] = i;
while (b % i == 0) {
djelitelji[1][brd]++;
b /= i;
}
brd++;
}
}
if (b > 1) {
djelitelji[0][brd] = b;
djelitelji[1][brd] = 1;
}
long long ind = 0;
while (djelitelji[0][ind] != 0) {
for (long long i = 1; i < 65; i++) {
faktori[ind][i] = n / pow(djelitelji[0][ind], i);
faktori[ind][0] += faktori[ind][i];
}
ind++;
}
long long mn = pow(2, 60);
for (int i = 0; i < 30; i++) {
if (djelitelji[0][i] == 0) {
break;
}
if (faktori[i][0] / djelitelji[1][i] < mn)
mn = faktori[i][0] / djelitelji[1][i];
}
cout << mn;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, evn = 0, odd = 0, o, e;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 0) {
evn++;
e = i + 1;
} else {
odd++;
o = i + 1;
}
}
if (evn > odd)
printf("%d\n", o);
else
printf("%d\n", e);
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, t;
scanf("%d %d", &n, &t);
if (n < 2 && t == 10)
printf("-1");
else if (t == 10) {
printf("10");
for (int i = 0; i < n - 2; i++) {
printf("0");
}
} else {
for (int i = 0; i < n; i++) {
printf("%d", t);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, M = 1e3 + 5, mod = 1e9 + 7;
template <typename T>
bool chmin(T& a, T b) {
return (b < a) ? a = b, 1 : 0;
}
template <typename T>
bool chmax(T& a, T b) {
return (b > a) ? a = b, 1 : 0;
}
long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (long long i = (0); i < (long long)(v.size()); ++i) cout << v[i] << ' ';
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
for (typename set<T>::iterator it = v.begin(); it != v.end(); ++it)
cout << *it << ' ';
return os;
}
void init() {}
long long p[N];
set<long long> s[N];
bool st[N];
long long find(long long x) { return x == p[x] ? x : p[x] = find(p[x]); }
void solve() {
long long n = read(), m1 = read(), m2 = read();
for (long long i = (1); i <= (long long)(n * 2); ++i) p[i] = i;
while (m1--) {
long long u = read(), v = read();
u = find(u), v = find(v);
for (long long x : s[u]) s[v].insert(x);
s[u].clear();
p[u] = v;
}
while (m2--) {
long long u = read(), v = read();
u += n, v += n;
u = find(u), v = find(v);
for (long long x : s[u]) s[v].insert(x);
s[u].clear();
p[u] = v;
}
vector<pair<long long, long long>> ans;
set<long long> ot;
for (long long x : s[find(1)]) st[x] = 1;
for (long long i = (1); i <= (long long)(n); ++i)
if (!st[i]) ot.insert(i);
memset(st, 0, sizeof st);
for (long long i = (1); i <= (long long)(n); ++i) {
if (st[find(i)]) continue;
st[find(i)] = 1;
for (long long j : ot) {
long long t1 = find(i), t2 = find(j), t3 = find(i + n), t4 = find(j + n);
if (t1 != t2 && t3 != t4) {
ans.push_back({i, j});
p[t2] = t1;
for (long long x : s[t2]) {
s[t1].insert(x);
auto p = ot.lower_bound(x);
if (p != ot.end()) ot.erase(p);
}
s[t2].clear();
p[t4] = t3;
for (long long x : s[t4]) s[t3].insert(x);
s[t4].clear();
}
}
}
cout << ans.size() << endl;
for (long long i = (0); i <= (long long)((long long)ans.size() - 1); ++i)
cout << ans[i].first << ' ' << ans[i].second << endl;
}
signed main() {
long long Case = 1;
init();
while (Case--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y;
int tc;
cin >> tc;
while (tc--) {
cin >> x >> y;
if (x - 1 == y) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
T gcd(T a, T b) {
while (a != 0) {
T temp = a;
a = b % a;
b = temp;
}
return b;
}
template <class T>
T egcd(T a, T b, T &x, T &y) {
T gcd, xt, yt;
if (a == 0) {
gcd = b;
x = 0, y = 1;
} else {
gcd = egcd(b % a, a, xt, yt);
x = yt - (b / a) * xt;
y = xt;
}
return gcd;
}
template <class T>
T expo(T base, T exp, T mod) {
T res = 1;
base = base % mod;
while (exp > 0) {
if (exp & 1) res = (res * base) % mod;
exp = exp >> 1;
base = (base * base) % mod;
}
return res;
}
template <class T>
T modinv(T a, T mod) {
T x, y;
egcd<T>(a, mod, x, y);
while (x < 0) x += mod;
while (x >= mod) x -= mod;
return x;
}
template <class T>
T modinvfermat(T a, T mod) {
return expo<T>(a, mod - 2, mod);
}
template <class T>
bool rev(T a, T b) {
return a > b;
}
template <class T>
long long maxpower(T a, T b) {
long long ans = 0;
while (a > 0 && a % b == 0) {
ans++;
a /= b;
}
return ans;
}
template <class T>
T mceil(T a, T b) {
if (a % b == 0)
return a / b;
else
return a / b + 1;
}
template <class T>
T lcm(T a, T b) {
return (a * b) / gcd<T>(a, b);
}
const long long infl = 1e18 + 5;
const int inf = 1e9 + 5;
void test_case() {
long long n;
cin >> n;
string s;
cin >> s;
long long cnt = 0;
char cur = s[0];
vector<long long> temp;
for (int i = (int)(0); i < (int)(n); i++) {
if (cur == s[i])
cnt++;
else {
temp.push_back(cnt);
cnt = 1;
cur = s[i];
}
}
if (((long long)(temp).size()) == 0) {
cout << mceil<long long>(cnt, 3) << '\n';
return;
} else if (s[n - 1] == s[0])
temp[0] += cnt;
else
temp.push_back(cnt);
long long ans = 0;
for (long long i : temp) ans += i / 3;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int _;
_ = 1;
cin >> _;
auto start = high_resolution_clock::now();
cout << setprecision(10);
while (_--) {
test_case();
}
auto stop = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop - start);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define rep(i ,n) for(int i=0;i<(int)(n);++i)
using namespace std;
typedef long long int int64;
typedef unsigned long long uint64;
int main(){
int n; cin >> n;
vector<int> a(n);
rep(i ,n) cin >> a[i];
int q; cin >> q;
rep(i ,q){
int com, b , e;
int _min , _max;
cin >> com >> b >> e;
if( com == 0 ) {
_min = 1000000001;
auto itr = a.begin() + b;
while( itr != a.begin() + e ){
if( *itr < _min ) _min = *itr;
++itr;
}
/*if( _min == 1000000001 ) cout << a[b] << endl;
else*/ cout << _min << endl;
} else if ( com == 1 ){
_max = -1000000001;
auto itr = a.begin() + b;
while( itr != a.begin() + e ){
if( *itr > _max) _max = *itr;
++itr;
}
/*if( _max == -1000000001 ) cout << a[e-1] << endl;
else*/ cout << _max << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
if (a == 0 && b != 0 && d != 0)
cout << "Ron";
else if (c == 0 && d != 0)
cout << "Ron";
else if ((b / a) * (d / c) * (f / e) > 1)
cout << "Ron";
else
cout << "Hermione";
}
| 1 |
//Code written by @pulkit0795
#include <iostream>
#include <vector>
#include <map>
#include <set>
using namespace std;
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
cin >> t;
while (t--)
{
int n, first;
cin >> n;
int a[n];
vector<int> v1;
map<int, int> mp_freq, mp2;
map<int, int>::iterator itr;
cin >> first;
v1.push_back(first);
a[0] = first;
for (int i = 1; i < n; i++)
{
cin >> a[i];
if (a[i - 1] == a[i])
{
continue;
}
else
{
v1.push_back(a[i]);
}
}
for (int i = 0; i < v1.size(); i++)
{
mp_freq[v1[i]]++;
}
set<int> s1;
for (itr = mp_freq.begin(); itr != mp_freq.end(); itr++)
{
int ans = itr->second - 1;
if (itr->first != v1[0])
{
ans++;
}
if (itr->first != v1[v1.size() - 1])
{
ans++;
}
s1.insert(ans);
}
cout << *s1.begin() << endl;
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<pair<int, int> > > edges(n + 1);
vector<bool> edgeisinserted(n - 1, 0);
vector<int> Directnodes(n + 1, 0);
int a = 0, b = 0;
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", &a, &b);
edges[a].push_back(pair<int, int>(b, i));
edges[b].push_back(pair<int, int>(a, i));
}
queue<int> q;
q.push(a);
int ans = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < edges[u].size(); i++) {
int v = edges[u][i].first;
int index = edges[u][i].second;
if (!edgeisinserted[index]) {
edgeisinserted[index] = 1;
ans += Directnodes[u];
Directnodes[u]++;
Directnodes[v]++;
q.push(v);
}
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T bigmod(T b, T p, T m) {
if (p == 0) return 1;
T res = bigmod(b, p / 2, m);
res = (res * res) % m;
if (p % 2 == 1) res = (res * b) % m;
return res;
}
int main() {
int i, j, k, n, m, d, a[10];
while (cin >> n) {
for (i = 0; i < 7; i++) cin >> a[i];
i = 0;
int sum = 0;
while (sum < n) {
i = i % 7;
sum = sum + a[i];
i++;
}
cout << i << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return (b == 0) ? a : gcd(b, a % b);
}
string add(char c, int l) {
string t;
while (l--) t += c;
return t;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
string ans;
map<char, int> m;
for (auto x : s) m[x]++;
for (auto x : m) ans += add(x.first, x.second);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793238462643l;
void solve();
int main() {
solve();
return 0;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void solve() {
long long a, b, x1, y1, x2, y2;
cin >> a >> b >> x1 >> y1 >> x2 >> y2;
long long ans1, ans2;
long long eps11 = 0, eps12 = 0, eps21 = 0, eps22 = 0;
if (x1 + y1 < 0) eps11 = -2 * a;
if (x2 + y2 < 0) eps12 = -2 * a;
if (x1 - y1 < 0) eps21 = -2 * b;
if (x2 - y2 < 0) eps22 = -2 * b;
ans1 = (x1 + y1 + eps11) / (2 * a) - (eps12 + x2 + y2) / (2 * a);
ans2 = (eps21 + x1 - y1) / (2 * b) - (eps22 + x2 - y2) / (2 * b);
if (ans1 < 0) ans1 = -ans1;
if (ans2 < 0) ans2 = -ans2;
cout << max(ans1, ans2);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
char c = getchar();
int num = 0;
while ('0' > c || c > '9') c = getchar();
while ('0' <= c && c <= '9') num = num * 10 + c - '0', c = getchar();
return (num);
}
long long mn, s0, s1;
int nm[1000010 * 2], n, a[1000010], ans, n0, n1;
inline int Abs(int x) {
if (x >= 0) return (x);
return (-x);
}
int main() {
n = Read();
for (int i = 1; i <= n; i++) a[i] = Read();
for (int i = 1; i <= n; i++) {
if (a[i] - i >= 0)
nm[a[i] - i]++, s0 += a[i] - i, n0++;
else
s1 += i - a[i], n1++;
mn += Abs(a[i] - i);
}
ans = 0;
for (int i = 1; i < n; i++) {
n1 += nm[i - 1], s1 += n1;
n0 -= nm[i - 1], s0 -= n0;
nm[i - 1] = 0;
s1 -= (n + 1 - a[n - i + 1]), n1--;
s0 += a[n - i + 1] - 1, n0++, nm[a[n - i + 1] - 1 + i]++;
if (mn > s0 + s1) mn = s0 + s1, ans = i;
}
printf("%I64d %d\n", mn, ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s1[100000 + 2], s2[32];
int main() {
scanf("%s%s", s1, s2);
int len1 = strlen(s1), len2 = strlen(s2);
int ans = 0;
for (int i = 0, j = 0; i < len1; i++) {
while (s1[i] == s2[j] && j < len2 && i < len1) {
i++, j++;
}
if (j == len2) {
ans++, i--;
} else {
i -= j;
}
j = 0;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int n,m;
int p[100005];
int y[100005];
vector<int>v[100005];
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
scanf("%d%d",&p[i],&y[i]);
v[p[i]].push_back(y[i]);
}
for(int i=1;i<=n;i++) sort(v[i].begin(),v[i].end());
for(int i=1;i<=m;i++){
printf("%06d",p[i]);
int k=lower_bound(v[p[i]].begin(),v[p[i]].end(),y[i])-v[p[i]].begin()+1;
printf("%06d\n",k);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
const double EPS = 1e-7;
const double PI = 3.1415926535897932384626;
const int MAXN = 222222;
const int MOD = 1000000007;
int n, a[MAXN], pred[MAXN], succ[MAXN];
std::vector<std::pair<int, int> > group;
int fpm(int a, long long b) {
int ret = 1;
for (; b; b >>= 1) {
if (b & 1) ret = 1ll * ret * a % MOD;
a = 1ll * a * a % MOD;
}
return ret;
}
int main() {
std::cin >> n;
for (int i = 1; i <= n; i++) std::cin >> a[i];
std::sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
int z = i;
while (i < n && a[i] == a[i + 1]) {
i++;
}
group.push_back(std::make_pair(a[i], i - z + 1));
}
for (int i = 0; i < group.size(); i++) {
pred[i] =
1ll * ((i == 0) ? 1 : pred[i - 1]) * (group[i].second + 1) % (MOD - 1);
}
succ[group.size()] = 1;
for (int i = (int)group.size() - 1; i >= 0; i--) {
succ[i] = 1ll * succ[i + 1] * (group[i].second + 1) % (MOD - 1);
}
int answer = 1;
for (int i = 0, size = group.size(); i < size; i++) {
long long exp = 0;
exp = (1ll * group[i].second * (group[i].second + 1) >> 1) % (MOD - 1);
exp = 1ll * exp * (i == 0 ? 1 : pred[i - 1]) % (MOD - 1) * succ[i + 1] %
(MOD - 1);
answer = 1ll * answer * fpm(group[i].first, exp) % MOD;
}
std::cout << answer << std::endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int K = 100005;
int n, m, k;
int t, p;
int l[N], c[N], x[K];
int main() {
scanf("%d%d%d", &n, &m, &k);
x[0] = 0;
for (int i = 1; i <= k; ++i) {
scanf("%d%d%d", &t, &p, &x[i]);
if (t == 1)
l[--p] = i;
else
c[--p] = i;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) printf("%d ", x[max(l[i], c[j])]);
printf("\n");
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(){
int n,s[12],o[12];
while(cin>>n){
if(!n)break;
int step=-1;
for(int i=0;i<n;++i) cin>>s[i];
for(int f=1;f;++step){
for(int i=0;i<n;++i) o[i]=s[i];
for(int i=0,count=0;i<n;++i){
count=0;
for(int j=0;j<n;++j){
if(o[i]==o[j])++count;
}
s[i]=count;
}
f=0;
for(int i=0;i<n;++i) if(s[i]!=o[i])f=1;
}
cout<<step<<"\n";
for(int i=0;i<n;++i) cout<<s[i]<<((i!=n-1)?" ":"\n");
}
return 0;
} | 0 |
#include <stdio.h>
int main(void)
{
int a[101];
int n;
int i;
for (i = 0; i < 101; i++){
a[i] = 0;
}
while (scanf("%d", &n) != EOF){
a[n]++;
if (a[0] < a[n]){
a[0] = a[n];
}
}
for (i = 1; i <= 100; i++){
if (a[i] == a[0]){
printf("%d\n", i);
}
}
return (0);
} | 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef long long ll;
const int INF = 1001001001;
int main() {
int n, m, l;
cin >> n >> m >> l;
vector<vector<int>> dist(n, vector<int>(n, INF));
rep(i, n) dist[i][i] = 0;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
if (c > l) continue;
dist[a][b] = dist[b][a] = c;
}
rep(k, n) rep(i, n) rep(j, n) chmin(dist[i][j], dist[i][k] + dist[k][j]);
vector<vector<int>> dist2(n, vector<int>(n, INF));
rep(i, n) rep(j, n) {
if (dist[i][j] <= l) dist2[i][j] = 1;
}
rep(k, n) rep(i, n) rep(j, n) chmin(dist2[i][j], dist2[i][k] + dist2[k][j]);
int q;
cin >> q;
rep(qi, q) {
int s, t;
cin >> s >> t;
--s;
--t;
int ans = dist2[s][t] - 1;
if (dist2[s][t] == INF) ans = -1;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 25;
const int inf = 1000000000;
int main() {
int n;
scanf("%d", &n);
int n1 = n / 2;
int n2 = n - n1;
vector<int> pow3(n2 + 1);
pow3[0] = 1;
for (int i = 1; i <= n2; i++) pow3[i] = 3 * pow3[i - 1];
int d[maxn][3];
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &d[i][0], &d[i][1], &d[i][2]);
}
map<pair<int, int>, int> m;
vector<int> value(pow3[n1]);
for (int i = 0; i < pow3[n1]; i++) {
int tmp = i;
int sum[3] = {};
for (int j = 0; j < n1; j++) {
int digit = tmp % 3;
tmp /= 3;
sum[0] += d[j][0];
sum[1] += d[j][1];
sum[2] += d[j][2];
sum[digit] -= d[j][digit];
}
pair<int, int> p(sum[0] - sum[1], sum[1] - sum[2]);
map<pair<int, int>, int>::iterator it = m.find(p);
;
value[i] = sum[0];
if (it == m.end()) {
m[p] = i;
} else {
if (sum[0] > value[it->second]) it->second = i;
if (sum[0] == value[it->second] && i > it->second) it->second = i;
}
}
int ans_value = -inf;
pair<int, int> ans;
for (int i = 0; i < pow3[n2]; i++) {
int tmp = i;
int sum[3] = {};
for (int j = n1; j < n; j++) {
int digit = tmp % 3;
tmp /= 3;
sum[0] += d[j][0];
sum[1] += d[j][1];
sum[2] += d[j][2];
sum[digit] -= d[j][digit];
}
pair<int, int> p(sum[1] - sum[0], sum[2] - sum[1]);
map<pair<int, int>, int>::iterator it = m.find(p);
;
if (it != m.end()) {
int _ans = sum[0] + value[it->second];
if (_ans > ans_value) {
ans_value = _ans;
ans = pair<int, int>(it->second, i);
}
if (_ans == ans_value && i > ans.second) {
ans = pair<int, int>(it->second, i);
}
}
}
if (ans_value == -inf) {
puts("Impossible");
} else {
for (int i = 0; i < n1; i++) {
int digit = ans.first % 3;
ans.first /= 3;
if (digit == 0) puts("MW");
if (digit == 1) puts("LW");
if (digit == 2) puts("LM");
}
for (int i = n1; i < n; i++) {
int digit = ans.second % 3;
ans.second /= 3;
if (digit == 0) puts("MW");
if (digit == 1) puts("LW");
if (digit == 2) puts("LM");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 2e5 + 42;
int n, inp[nmax];
int least[nmax * 2];
int outp;
vector<int> seen[nmax];
void solve_small(int big, int small) {
for (int i = 1; i + 1 < seen[small].size(); i++)
for (int j = i; j + 1 < seen[small].size(); j++) {
int l = lower_bound(seen[big].begin(), seen[big].end(), seen[small][i]) -
seen[big].begin();
int r = upper_bound(seen[big].begin(), seen[big].end(), seen[small][j]) -
seen[big].begin();
if (j - i + 1 < r - l + 1) continue;
for (int l_border = l;
l_border > 0 && seen[big][l_border] > seen[small][i - 1];
l_border--) {
int r_border = l_border + j - i;
if (r_border + 1 >= seen[big].size()) continue;
int valid_l = seen[big][l_border - 1] + 1,
valid_r = seen[big][r_border + 1] - 1;
if (valid_l > seen[small][i] || valid_r < seen[small][j]) break;
outp = max(outp, valid_r - valid_l + 1);
}
}
}
void solve_big(int big, int small) {
for (int i = 0; i <= 2 * n; i++) least[i] = -1;
least[n] = 0;
int sum = n;
for (int i = 1; i <= n; i++) {
if (inp[i] == big)
sum++;
else if (inp[i] == small)
sum--;
if (least[sum] != -1) outp = max(outp, i - least[sum]);
if (least[sum] == -1) least[sum] = i;
}
}
int main() {
scanf("%i", &n);
int C = pow(n / 2.0, 1.0 / 3);
for (int i = 1; i <= n; i++) seen[i].push_back(0);
for (int i = 1; i <= n; i++) {
scanf("%i", &inp[i]);
seen[inp[i]].push_back(i);
}
for (int i = 1; i <= n; i++) seen[i].push_back(n + 1);
map<int, int> cnt = {};
for (int i = 1; i <= n; i++) cnt[inp[i]]++;
int maxi = inp[1];
for (auto k : cnt)
if (k.second > cnt[maxi]) maxi = k.first;
for (auto k : cnt)
if (k.first != maxi) {
if (k.second > C)
solve_big(maxi, k.first);
else
solve_small(maxi, k.first);
}
printf("%i\n", outp);
return 0;
}
| 4 |
#include <cstdio>
#include <cstring>
using namespace std;
#define rep(i,l,r) for (int i=(l);i<=(r);i++)
const int maxn=20;
int a[maxn],b[maxn];
bool u[maxn];
int n,m;
int main() {
while (scanf("%d%d\n",&n,&m),n+m) {
rep(i,1,n) scanf("%d",a+i);
rep(i,1,m) scanf("%d",b+i);
memset(u,true,sizeof(u));
rep(i,1,m) {
rep(j,1,n)
if (u[j]&&a[j]==b[i]) {
u[j]=false;
b[i]=0;
break;
}
}
int ans=0;
rep(i,1,n) ans+=a[i];
rep(i,1,m) ans+=b[i];
printf("%d\n",ans);
}
return 0;
} | 0 |
#include<cstdio>
#include<string.h>
int main(){
int i,j;
char s[12]={},t[12]={};
for(;~scanf("%s",s);printf("%d\n",*s)){
for(i=0;i<12;++i)s[i]-=48;
for(i=0;i<9;memcpy(s,t,12),++i)
for(j=0;i<9-j;++j)
t[j]=(s[j]+s[j+1])%10;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, N, b[300000], c[300000];
long long f[300000], a[300000];
bool cmp(int x, int y) { return a[x] < a[y]; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]), c[i] = i;
sort(c + 1, c + n + 1, cmp);
for (int i = 1; i <= n; i++) {
f[i] = 1e18;
for (int j = 3; j <= min(6, i); j++) {
f[i] = min(f[i], f[i - j] + a[c[i]] - a[c[i - j + 1]]);
}
}
for (int i = n; i;) {
for (int j = 3; j <= min(6, i); j++)
if (f[i] == f[i - j] + a[c[i]] - a[c[i - j + 1]]) {
++N;
for (int k = 1; k <= j; k++) b[c[i - k + 1]] = N;
i = i - j;
break;
}
}
printf("%lld %d\n", f[n], N);
for (int i = 1; i <= n; i++) printf("%d ", b[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int arr[n], brr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n; i++) {
cin >> brr[i];
}
if (arr[0] == 0)
cout << "NO";
else if (arr[0] == 1 && arr[s - 1] == 1)
cout << "YES";
else {
int cnt = 0;
for (int i = s; i < n; i++) {
if (arr[i] == 1 && brr[i] == 1 && brr[s - 1] == 1) {
cout << "YES";
cnt = 1;
break;
}
}
if (cnt != 1) cout << "NO";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int limN = 1005;
int ans[limN][limN];
int main() {
int n, d, k;
scanf("%d%d%d", &n, &k, &d);
if (n == 1) {
for (int i = 0; i < d; i++) printf("1\n");
return 0;
}
if (k >= n) {
for (int i = 0; i < d; i++) {
for (int j = 1; j <= n; j++) printf("%d ", j);
printf("\n");
}
return 0;
}
if (d == 1 || k == 1) {
printf("-1\n");
return 0;
}
int num[limN];
for (int i = 0; i < d; i++) num[i] = 0;
for (int w = 0; w < n; w++) {
for (int i = 0; i < d; i++) {
ans[i][w] = num[i] + 1;
}
int xtra = 1;
for (int i = 0; i < d && xtra; i++) {
num[i] += xtra;
xtra = num[i] / k;
num[i] %= k;
}
if (xtra && w + 1 < n) {
printf("-1\n");
return 0;
}
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < n; j++) printf("%d ", ans[i][j]);
printf("\n");
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[101];
bool V[101];
bool Vis[101];
int DP[101];
int N;
int Ans = 0;
void DFS(int n,int len){
Ans = max(Ans,len);
DP[n] = max(DP[n],len);
int S = G[n].size();
for(int i=0;i<S;i++){
if(!V[G[n][i]]){
Vis[G[n][i]]= true;
V[G[n][i]] = true;
DFS(G[n][i],len+1);
V[G[n][i]] = false;
}
}
return;
}
int main(){
do{
int i;
for(i=0;i<101;i++){
G[i].clear();
V[i] = false;
Vis[i] = false;
DP[i] = 0;
}
Ans = 0;
scanf("%d",&N);
if(N==0)break;
for(i=0;i<N;i++){
int A,B;
scanf("%d%d",&A,&B);
G[A].push_back(B);
G[B].push_back(A);
}
for(i=1;i<=100;i++){
if(!Vis[i]){
Vis[i] =true;
V[i] = true;
DFS(i,1);
V[i] = false;
}
}
for(i=1;i<=100;i++){
if(DP[i]==Ans){
V[i] = true;
DFS(i,1);
V[i] = false;
break;
}
}
printf("%d\n",Ans);
}while(true);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int maxn = 2e5 + 5;
int Bit[maxn], A[maxn], n;
pair<int, int> P[maxn];
void Update(int i) {
while(i <= n) {
Bit[i]++;
i += i&(-i);
}
}
int Getsum(int i) {
int res = 0;
while(i) {
res += Bit[i];
i -= i&(-i);
}
return res;
}
int main() {
scanf("%d", &n);
for(int i = 0; i < n; i++)
scanf("%d%d", &P[i].first, &P[i].second);
sort(P, P+n);
for(int i = 0; i < n; i++) {
P[i].first = P[i].second;
P[i].second = i;
}
sort(P, P+n);
A[0] = 1;
for(int i = 1; i <= n; i++) {
A[i] = A[i-1]<<1;
if(A[i] >= MOD) A[i] -= MOD;
}
int ans = (long long)n*A[n]%MOD;
for(int i = 0; i < n; i++) {
int j = P[i].second, k = Getsum(j);
int a = A[k], b = A[i-k], c = A[j-k], d = A[n-1-(i+j-k)];
ans = (ans-(long long)(a+d-1)*(b+c-1)%MOD) % MOD;
Update(j+1);
}
if(ans < 0) ans += MOD;
printf("%d", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int n, cnt;
int ans[1005];
bool prime(int x) {
for (int i = 2; i < x; i++)
if (x % i == 0) return 0;
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
if (!prime(i)) continue;
int p = i;
while (p <= n) {
ans[++cnt] = p;
p *= i;
}
}
printf("%d\n", cnt);
for (int i = 1; i < cnt; i++) printf("%d ", ans[i]);
if (cnt) printf("%d\n", ans[cnt]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, sum, res[100001], m, a[100001], q, k;
map<int, bool> u[100001];
int main() {
scanf("%d %d", &n, &m);
q = 100000;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
u[a[i]][a[i]] = 1;
q = min(q, a[i]);
}
while (m--) {
scanf("%d %d", &i, &j);
if (u[a[i]][a[j]] == 0) {
res[a[i]]++;
u[a[i]][a[j]] = 1;
}
if (u[a[j]][a[i]] == 0) {
res[a[j]]++;
u[a[j]][a[i]] = 1;
}
}
k = 0;
for (i = 1; i <= n; i++)
if (res[a[i]] > k || (res[a[i]] >= k && a[i] < q)) {
k = res[a[i]];
q = a[i];
}
printf("%d\n", q);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string i2s(int a) {
string res = "";
while (a > 0) {
res += char(a % 10 + '0');
a /= 10;
}
return res;
}
int s2i(string s) {
int res = 0;
int j = 1;
for (int i = 0; i < s.length(); i++) {
res += int(s[i] - '0') * j;
j *= 10;
}
return res;
}
int main() {
string s;
cin >> s;
s += "#";
int a[100];
int c = 1;
int j = 0;
for (int i = 0; i < s.length() - 1; i++) {
if (s[i] != s[i + 1]) {
a[j] = c;
c = 0;
j++;
}
c++;
}
int res = 0;
for (int i = 0; i < j; i++) {
res += a[i] / 5;
res += a[i] % 5 != 0 ? 1 : 0;
}
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> B[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int k, a;
scanf("%d%d", &k, &a);
B[i] = make_pair(k, a);
}
sort(B, B + n);
for (int i = 1; i < n; ++i) {
int p = 2 * (B[i].first - B[i - 1].first);
if (p >= 30) continue;
p = 1 << p;
int k = (B[i - 1].second + p - 1) / p;
if (k > B[i].second) B[i].second = k;
}
int k = B[n - 1].first, a = B[n - 1].second;
do {
++k;
a = (a + 3) / 4;
} while (a > 1);
printf("%d\n", k);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long 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 modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
long long seg[800001][2];
void insert(int idx, int s, int e, int p, int v1, int v2) {
if (s == e) {
seg[idx][0] = v1;
seg[idx][1] = v2;
return;
}
int mid = (s + e) / 2;
if (p <= mid)
insert(idx * 2 + 1, s, mid, p, v1, v2);
else if (p > mid)
insert(idx * 2 + 2, mid + 1, e, p, v1, v2);
seg[idx][0] = max(seg[idx * 2 + 1][0], seg[idx * 2 + 2][0]);
seg[idx][1] = max(seg[idx * 2 + 1][1], seg[idx * 2 + 2][1]);
}
pair<int, int> query(int idx, int s, int e, int st, int ed) {
if (s == st && e == ed) {
return make_pair(seg[idx][0], seg[idx][1]);
}
int mid = (s + e) / 2;
if (ed <= mid)
return query(idx * 2 + 1, s, mid, st, ed);
else if (st > mid)
return query(idx * 2 + 2, mid + 1, e, st, ed);
else {
pair<int, int> p1 = query(idx * 2 + 1, s, mid, st, mid);
pair<int, int> p2 = query(idx * 2 + 2, mid + 1, e, mid + 1, ed);
return make_pair(max(p1.first, p2.first), max(p1.second, p2.second));
}
}
long long ar[200011], hi[200011], dp[200011][2];
vector<int> vc[200011], vp[200011];
long long dis[200011], P[200011][22], pre[200011];
void dfs(int c, int p, long long d) {
dis[c] = d;
pre[c] = p;
for (int i = (0); i < (vc[c].size()); ++i) {
dfs(vc[c][i], c, d + vp[c][i]);
}
}
void pre_process(int N) {
memset(P, -1, sizeof P);
for (int i = 1; i <= N; i++) P[i][0] = pre[i];
for (int j = 1; (1 << j) <= N; j++) {
for (int i = N; i >= 1; i--) {
if (P[i][j - 1] != -1) P[i][j] = P[P[i][j - 1]][j - 1];
}
}
}
int LCA(int p, int q, int N) {
for (int i = p; i <= N;) {
int c = P[i][0];
if (c > q) return i;
for (int j = 1; j <= 21; j++) {
if (P[i][j] == -1) break;
if (P[i][j] > q) break;
c = P[i][j];
}
i = c;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a = 0, b, c = 0, d, e = 0, f = 0, g = 0, h = 0, x, y, z;
cin >> a;
for (int i = (1); i < (a + 1); ++i) {
cin >> ar[i] >> hi[i];
insert(0, 1, a, i, i, ar[i] + hi[i]);
}
ar[a + 1] = ar[a];
for (int i = a; i >= 1; i--) {
b = upper_bound(ar + 1, ar + 1 + a, ar[i] + hi[i]) - ar;
b--;
pair<int, int> pp = query(0, 1, a, i, b);
dp[i][0] = pp.first;
dp[i][1] = max((long long)pp.second, ar[i] + hi[i]);
insert(0, 1, a, i, dp[i][0], dp[i][1]);
vc[pp.first + 1].push_back(i);
vp[pp.first + 1].push_back(ar[pp.first + 1] - pp.second);
}
dfs(a + 1, a + 2, 0);
pre_process(a + 1);
cin >> b;
for (int i = (0); i < (b); ++i) {
cin >> c >> d;
e = LCA(c, d, a + 1);
cout << dis[c] - dis[e] << endl;
}
}
| 5 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
int n; cin >> n;
vector<ll> A(n + 1, 0), greedy(n + 1, 0), dp(n + 1, 0);
for(int i = 1; i <= n; i ++) cin >> A[i];
greedy[1] = A[1];
for(int i = 3; i <= n; i += 2){
greedy[i] = greedy[i - 2] + A[i];
}
for(int i = 2; i <= n; i ++){
if(i & 1){
dp[i] = max(dp[i - 1], dp[i - 2] + A[i]);
}
else{
dp[i] = max(dp[i - 2] + A[i], greedy[i - 1]);
}
}
cout << dp[n] << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1004], t[1004];
int main() {
for (int i = 0; i < 1004; i++) a[i] = 2147483647;
scanf("%d", &n);
int i = 0, k = 1;
for (k = 1; k <= n; k <<= 1) i++;
for (i--; i >= 0; i--) {
for (int j = 0; j < 2; j++) {
int ts = 0;
for (int k = 1; k <= n; k++)
if (((k >> i) & 1) == j) t[ts++] = k;
if (ts == 0) continue;
printf("%d\n", ts);
for (int k = 0; k < ts; k++) printf("%d ", t[k]);
puts("");
fflush(stdout);
for (int k = 1; k <= n; k++) scanf("%d", t + k);
for (int k = 1; k <= n; k++)
if (((k >> i) & 1) != j) a[k] = min(a[k], t[k]);
}
}
puts("-1");
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
puts("");
fflush(stdout);
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> v(n);
for (auto &e : v) cin >> e;
long long int sum = 0, ans = 0;
map<long long int, int> mp;
mp[0] = 1;
for (auto e : v) {
sum += e;
if (mp[sum] == 1) {
ans++;
mp.clear();
mp[0] = 1;
sum = e;
}
mp[sum] = 1;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
char a[1000009], b[1000009];
long long num[30], n, rev[1000009], ans = 1;
long long pw(long long u, long long v) {
if (v == 1) return u;
long long res = pw(u, v / 2);
res = (res * res) % mod;
if (v % 2 > 0) res = (res * u) % mod;
return res;
}
long long solve(char s[1000009]) {
long long cur = n;
long long res = 0;
long long f[1000009];
long long cnt[30];
for (long long i = 0; i < n; i++) f[i] = s[i] - 'a';
for (long long i = 0; i < 26; i++) cnt[i] = num[i];
long long sum = ans;
for (long long i = 0; i < n; i++) {
sum = (sum * rev[cur]) % mod;
cur--;
for (long long j = 0; j < f[i]; j++) res = (res + sum * cnt[j]) % mod;
if (cnt[f[i]] == 0) break;
sum = (sum * cnt[f[i]]) % mod;
cnt[f[i]]--;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin >> a >> b;
n = strlen(a);
for (long long i = 1; i <= n; i++)
rev[i] = pw(i, mod - 2), ans = (ans * i) % mod;
for (long long i = 0; i < n; i++) num[a[i] - 'a']++;
for (long long i = 0; i < 26; i++)
for (long long j = 1; j <= num[i]; j++) ans = (ans * rev[j]) % mod;
cout << (solve(b) - solve(a) - 1 + mod) % mod;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int s[n];
int e[n];
for (int i = 0; i < n; i++) {
cin >> s[i] >> e[i];
}
int i = n - 1;
for (; i >= 0; i--)
if (s[i] <= m && e[i] >= m) break;
int j = i;
while (i >= 0) {
if (s[i] <= s[j] && e[i] >= s[j]) j = i;
i--;
}
if (s[j] == 0)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, ans = 0, i, j;
long long a[13];
for (n = 1; n <= 12; ++n) {
ans = 0;
for (i = 0; i < 9; ++i) {
for (j = 0; j < 9; ++j) {
if (i >= 1 && j >= 5) continue;
if (n - i - j + 1 > 0) ans += n - i - j + 1;
}
}
a[n] = ans;
}
cin >> n;
if (n <= 12)
cout << a[n];
else
cout << a[12] + 49ll * (n - 12);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int arr[100005], arr2[100005];
int n, a, c, g, t, q, max1, sum;
using namespace std;
void O_o() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
int main() {
O_o();
bool b = 0;
string s;
cin >> n;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'A') a++;
if (s[i] == 'C') c++;
if (s[i] == 'G') g++;
if (s[i] == 'T') t++;
if (s[i] == '?') q++;
}
max1 = max(a, max(c, max(g, t)));
sum += max1 - a;
sum += max1 - c;
sum += max1 - g;
sum += max1 - t;
if (sum > q)
cout << "===" << endl;
else {
for (int i = 0; i < s.size(); i++) {
if (s[i] == '?') {
if (a != max1) {
s[i] = 'A';
a++;
q--;
} else if (c != max1) {
s[i] = 'C';
c++;
q--;
} else if (g != max1) {
s[i] = 'G';
g++;
q--;
} else if (t != max1) {
s[i] = 'T';
t++;
q--;
}
}
}
if (q != 0) {
if (q % 4 == 0) {
a = q / 4;
c = q / 4;
g = q / 4;
t = q / 4;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '?') {
if (a != 0) {
s[i] = 'A';
a--;
} else if (c != 0) {
s[i] = 'C';
c--;
} else if (g != 0) {
s[i] = 'G';
g--;
} else if (t != 0) {
s[i] = 'T';
t--;
}
}
}
} else
b = 1;
}
if (b == 1)
cout << "===" << endl;
else
cout << s << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#ifdef DEBUG
#define debug(...) fprintf(stderr, __VA_ARGS__)
#else
#define debug(...)
#endif
#ifdef __WIN32
#define LLFORMAT "I64"
#define Rand() ((rand() << 15) + rand())
#else
#define LLFORMAT "ll"
#define Rand() (rand())
#endif
using namespace std;
const int maxn = 6, maxc = 51, maxm = maxn * maxc, maxs = (1 << maxn - 1) | 10;
int n, m, C, l[maxn], p[maxn], S;
long long dp[maxm][maxs], tot, mu;
inline int lowbit(int i) { return i & (-i); }
int main() {
scanf("%d%d", &n, &C); m = n * C; S = 1 << n - 1;
for (int i = 0; i < n; ++i) scanf("%d", l + i), p[i] = i;
sort(l, l + n); reverse(l, l + n);
do {
memset(dp, 0, sizeof dp); dp[l[0] * n][0] = 1;
for (int i = 0; i < m; ++i) for (int j = i; j <= m; ++j) for (int k, s = 0; s < S; ++s) if(dp[j][s] && (k = i % n) && !((s >> k - 1) & 1)) dp[min(m, max(j, i + l[p[k]] * n))][s | (1 << k - 1)] += dp[j][s];
tot += dp[m][S - 1];
++mu;
} while(next_permutation(p + 1, p + n));
for (int i = 1; i < n; ++i) mu *= (long long) C;
printf("%.12f\n", (double) tot / (double) mu);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, x, y;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
cin >> n >> x >> y;
if (x > y) swap(x, y);
long long tot = x + y;
int guy;
if (x == n)
guy = tot - (n - 1) + 1;
else
guy = tot - n + 1;
if (guy == y) guy++;
if (guy < 1) guy = 1;
if (guy > n)
cout << n << ' ';
else if (guy > y)
cout << n - (n - guy + 1) << ' ';
else
cout << n - (n - guy) << ' ';
if (x == 1)
guy = tot - 2;
else
guy = tot - 1;
if (guy == y) guy--;
if (guy > n) guy = n;
if (guy < 1)
cout << 1 << '\n';
else if (guy < y)
cout << guy + 1 << '\n';
else
cout << guy << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
const int N = 150010, mod = 998244353;
int Pow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = res * (long long)x % mod;
x = x * (long long)x % mod, y >>= 1;
}
return res;
}
int head[N], ecnt;
int sz[N], fa[N];
struct ed {
int to, next;
} e[N << 1];
void ad(int x, int y) {
e[++ecnt] = (ed){y, head[x]};
head[x] = ecnt;
e[++ecnt] = (ed){x, head[y]};
head[y] = ecnt;
}
namespace __ {
int *U[N], *D[N];
int dep[N], son[N], top[N];
int dis[N];
int p[N][19];
void dfs1(int u, int last) {
fa[u] = p[u][0] = last, dis[u] = dis[last] + 1;
sz[u] = 1;
for (int j = 1; j <= 18; ++j) p[u][j] = p[p[u][j - 1]][j - 1];
for (int k = head[u]; k; k = e[k].next) {
int v = e[k].to;
if (v == last) continue;
dfs1(v, u);
if (dep[v] >= dep[u]) dep[u] = dep[v], son[u] = v;
sz[u] += sz[v];
}
dep[u]++;
}
void dfs2(int u, int tp) {
top[u] = tp;
if (son[u]) dfs2(son[u], tp);
for (int k = head[u]; k; k = e[k].next) {
int v = e[k].to;
if (v == p[u][0] || v == son[u]) continue;
dfs2(v, v);
}
}
void gao(int u) {
U[u] = new int[dep[u] + 1];
D[u] = new int[dep[u] + 1];
int cur = u;
for (int i = 0; i <= dep[u]; ++i) D[u][i] = cur, cur = son[cur];
cur = u;
for (int i = 0; i <= dep[u]; ++i) U[u][i] = cur, cur = p[cur][0];
}
int Lg[N];
int query(int u, int k) {
if (dis[u] <= k) return 0;
if (!k) return u;
u = p[u][Lg[k]], k -= (1 << Lg[k]);
int td = dis[u] - dis[top[u]];
if (td >= k)
return D[top[u]][td - k];
else
return U[top[u]][k - td];
}
} // namespace __
struct Que {
int u, d;
};
vector<Que> s;
int n, q;
int delt[N], del[N];
int ans[N];
void push_down(int u, int last) {
del[u] = (del[last] + del[u]) % mod;
ans[u] = (ans[u] + del[u]) % mod;
for (int k = head[u]; k; k = e[k].next) {
int v = e[k].to;
if (v == last) continue;
push_down(v, u);
}
del[u] = 0;
}
int get(int v, int u) {
if (__::dis[v] > __::dis[u]) return sz[v];
if (__::dis[v] == __::dis[u]) {
if (v == u) return n;
return sz[v];
}
int t = __::query(u, __::dis[u] - __::dis[v] - 1);
if (fa[t] == v)
return n - sz[t];
else
return sz[v];
}
int main() {
rd(n), rd(q);
int inv = Pow(n, mod - 2);
for (int i = 1, x, y; i < n; ++i) rd(x), rd(y), ad(x, y);
__::dfs1(1, 0), __::dfs2(1, 1);
for (int i = 1; i <= n; ++i)
if (__::top[i] == i) __::gao(i);
for (int i = 2; i <= n; ++i) __::Lg[i] = __::Lg[i >> 1] + 1;
for (int i = 1; i <= q; ++i) {
int ty, v, d;
rd(ty), rd(v);
if (ty == 1) {
rd(d);
delt[v] = (delt[v] + d) % mod;
s.push_back((Que){v, d});
} else {
long long t = ans[v];
for (int j = 0; j < s.size(); ++j)
t = (t + get(s[j].u, v) * (long long)s[j].d) % mod;
printf("%lld\n", (t * (long long)inv % mod + mod) % mod);
}
if (s.size() > 400) {
for (int u = 1; u <= n; ++u)
if (delt[u]) {
for (int k = head[u]; k; k = e[k].next) {
int v = e[k].to;
if (v == fa[u]) continue;
del[v] = (del[v] + (n - sz[v]) * (long long)delt[u]) % mod;
}
del[1] = (del[1] + sz[u] * (long long)delt[u]) % mod;
del[u] = (del[u] - sz[u] * (long long)delt[u]) % mod;
ans[u] = (ans[u] + n * (long long)delt[u]) % mod;
delt[u] = 0;
}
push_down(1, 0);
s.clear();
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long long max9 = 10 + 1e9, max6 = 10 + 1e6, max12 = 10 + 1e12,
max15 = 10 + 1e15;
const long long min6 = -1 * max6, min9 = -1 * max9, min12 = -1 * max12,
min15 = -1 * max15;
const long long R = 7 + 1e9, NN = 10 + 1e5;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
double ans = 0;
int u, v;
for (int i = (0); i < (n); ++i) {
int x, y;
cin >> x >> y;
if (i == 0) {
u = x;
v = y;
continue;
}
ans += sqrt((u - x) * (u - x) + (v - y) * (v - y));
u = x;
v = y;
}
ans *= k / 50.0;
cout << setprecision(40) << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
int inf = 1e9;
struct seg {
int l, r, mid, ma = 0, lz = 0;
seg *ch[2] = {NULL, NULL};
void push() {
for (auto &i : ch) i->lz += lz, i->ma += lz;
lz = 0;
}
void add(int _l, int _r, int val) {
if (_l <= l and _r >= r) {
lz += val, ma += val;
return;
}
if (_l > r or _r < l) return;
push();
for (auto &i : ch) i->add(_l, _r, val);
ma = max(ch[0]->ma, ch[1]->ma);
}
seg(int _l, int _r) {
l = _l, r = _r, mid = l + r >> 1;
if (l != r) {
ch[0] = new seg(l, mid);
ch[1] = new seg(mid + 1, r);
}
}
};
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
int p[n], pos[n + 1], b[n];
for (int i = 0; i < n; i++) cin >> p[i], pos[p[i]] = i;
for (int &i : b) cin >> i, i--;
int ans = n;
seg *rt = new seg(0, n - 1);
rt->add(0, pos[n], 1);
for (int i = 0; i < n; i++) {
cout << ans << ' ';
rt->add(0, b[i], -1);
while (rt->ma <= 0) {
ans--;
rt->add(0, pos[ans], 1);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int mp = 0;
int mn = INT_MIN;
long long int s = 0;
int p = 0, ne = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= 0) {
if (ne > 0) {
s += mn;
ne = 0;
}
if (mp <= a[i]) {
mp = a[i];
p = 1;
}
mn = INT_MIN;
} else {
if (p > 0) {
s += mp;
p = 0;
}
if (mn <= a[i]) {
mn = a[i];
ne = 1;
}
mp = 0;
}
}
if (p != 0) s += mp;
if (ne != 0) s += mn;
cout << s << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int cnt[N + 1];
int check[N + 1];
set<pair<int, int> > s;
int main() {
int n, A;
scanf("%d %d", &n, &A);
for (int i = 1; i <= N; i++) {
cnt[i] = 0;
s.insert({cnt[i], i});
}
for (int i = 0; i < n; i++) {
int foo;
scanf("%d", &foo);
if (!check[foo]) {
s.erase(s.find({cnt[foo], foo}));
s.insert({++cnt[foo], foo});
}
while ((!s.empty()) && s.begin()->first < cnt[A]) {
check[s.begin()->second] = 1;
s.erase(s.begin());
}
}
for (auto x : s) {
if (x.second != A) {
cout << x.second << endl;
return 0;
}
}
puts("-1");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
int h, a[MX];
int hed[MX];
int main() {
ios::sync_with_stdio(false);
cin >> h;
for (int i = 0; i <= h; i++) cin >> a[i];
int it = -1;
for (int i = 1; i <= h; i++)
if (a[i] > 1 && a[i - 1] > 1) {
it = i;
break;
}
if (it == -1)
cout << "perfect" << endl;
else {
cout << "ambiguous" << endl;
hed[0] = 1;
for (int i = 1; i <= h + 1; i++) hed[i] = hed[i - 1] + a[i - 1];
for (int i = 0; i <= h; i++)
for (int j = 1; j <= a[i]; j++) cout << (i ? hed[i - 1] : 0) << ' ';
cout << endl;
for (int i = 0; i <= h; i++)
for (int j = 1; j <= a[i]; j++)
cout << (i ? (i == it && j > 1 ? hed[i] - 1 : hed[i - 1]) : 0) << ' ';
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int T;
long long a, m, ans;
long long gcd(long long a, long long b) {
while (b) a %= b, std::swap(a, b);
return a;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%lld%lld", &a, &m);
ans = gcd(a, m), a /= ans, m /= ans, ans = m;
for (long long i = 2; (long long)i * i <= m; ++i) {
if (m % i == 0) {
ans /= i, ans *= (i - 1);
while (m % i == 0) m /= i;
}
}
if (m > 1) ans /= m, ans *= (m - 1);
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
const int SS = 4 * N;
struct Query {
int l, r, val;
};
int add[SS], seg[SS];
vector<Query> q[N];
vector<int> cy, cx;
int xl[N], yl[N], xr[N], yr[N];
void comp(vector<int> &v) {
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
}
void set_comp(int &val, vector<int> &v) {
val = lower_bound(v.begin(), v.end(), val) - v.begin();
}
void build(int s = 0, int e = cy.size() - 1, int v = 1) {
if (e - s == 1) {
seg[v] = cy[e] - cy[s];
return;
}
int mid = (s + e) / 2;
build(s, mid, 2 * v);
build(mid, e, 2 * v + 1);
seg[v] = seg[2 * v] + seg[2 * v + 1];
}
void upd(int l, int r, int val, int s = 0, int e = cy.size() - 1, int v = 1) {
if (l >= e || r <= s) return;
if (l <= s && e <= r) {
add[v] += val;
return;
}
int mid = (s + e) / 2;
upd(l, r, val, s, mid, 2 * v);
upd(l, r, val, mid, e, 2 * v + 1);
seg[v] =
seg[2 * v] * (add[2 * v] == 0) + seg[2 * v + 1] * (add[2 * v + 1] == 0);
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> xl[i] >> yl[i] >> xr[i] >> yr[i];
if (xl[i] > xr[i]) swap(xl[i], xr[i]);
if (yl[i] > yr[i]) swap(yl[i], yr[i]);
xr[i]++;
yr[i]++;
cx.push_back(xl[i]);
cx.push_back(xr[i]);
cy.push_back(yl[i]);
cy.push_back(yr[i]);
}
comp(cx);
comp(cy);
build();
for (int i = 0; i < n; i++) {
set_comp(xl[i], cx);
set_comp(xr[i], cx);
set_comp(yl[i], cy);
set_comp(yr[i], cy);
q[xl[i]].push_back({yl[i], yr[i], 1});
q[xr[i]].push_back({yl[i], yr[i], -1});
}
long long ans = 0;
for (int i = 0; i < cx.size(); i++) {
for (int j = 0; j < q[i].size(); j++)
upd(q[i][j].l, q[i][j].r, q[i][j].val);
if (i + 1 < cx.size())
ans += 1LL * (cy.back() - cy[0] - (add[1] == 0) * seg[1]) *
(cx[i + 1] - cx[i]);
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int i, n, m, j, k, c;
scanf("%d %d", &n, &m);
i = 1;
c = 1;
while (i <= n) {
if (i % 2 != 0) {
j = 0;
while (j < m) {
printf("#");
j++;
}
} else {
if (c % 2 != 0) {
printf("\n");
k = 0;
while (k < m - 1) {
printf(".");
k++;
}
printf("#\n");
} else {
printf("\n#");
k = 0;
while (k < m - 1) {
printf(".");
k++;
}
printf("\n");
}
c++;
}
i++;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
long long n, m, k;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int t = 1;
while (t--) {
cin >> n;
int o = 0, tw = 0;
for (int i = 0; i < n; i++) cin >> m, o += m == 1, tw += m == 2;
if (tw) cout << "2 ", tw--;
if (o) cout << "1 ", o--;
for (int i = 0; i < tw; i++) cout << "2 ";
for (int i = 0; i < o; i++) cout << "1 ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7;
using pii = std::pair<long long, long long>;
using namespace std;
const long long maxn = 1e5 + 5;
long long n, a, r, m, h[maxn], pref[maxn], alth[maxn];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> a >> r >> m;
for (long long i = 0; i < n; i++) cin >> h[i];
sort(h, h + n);
pref[0] = h[0];
for (long long i = 1; i < n; i++) pref[i] = pref[i - 1] + h[i];
long long ans = 2e18;
for (long long i = 0; i < n; i++) {
long long cur = h[i];
long long linc = (i + 1) * h[i] - pref[i];
long long rlen = n - 1 - i;
long long rdec = (pref[n - 1] - pref[i]) - rlen * h[i];
ans = min(ans, linc * a + rdec * r);
long long common = min(linc, rdec);
linc -= common;
rdec -= common;
ans = min(ans, common * m + linc * a + rdec * r);
}
long long avg = pref[n - 1] / n;
for (long long i = 0; i < n; i++) alth[i] = h[i];
long long i = 0, j = n - 1, steps = 0;
while (i < j && alth[i] < avg && alth[j] > avg) {
long long take = min(avg - alth[i], alth[j] - avg);
alth[i] += take;
alth[j] -= take;
steps += take;
if (alth[i] == avg) i++;
if (alth[j] == avg) j--;
}
long long red = 0, inc = 0;
for (long long k = i; k <= j; k++)
if (alth[k] < avg)
inc += avg - alth[k];
else
red += alth[k] - avg;
assert(red == 0 || inc == 0);
ans = min(ans, steps * m + inc * a + red * r);
for (long long i = 0; i < n; i++) alth[i] = h[i];
i = 0, j = n - 1, steps = 0;
while (i < j && alth[i] < avg + 1 && alth[j] > avg + 1) {
long long take = min((avg + 1) - alth[i], alth[j] - (avg + 1));
alth[i] += take;
alth[j] -= take;
steps += take;
if (alth[i] == avg + 1) i++;
if (alth[j] == avg + 1) j--;
}
red = 0, inc = 0;
for (long long k = i; k <= j; k++)
if (alth[k] < avg + 1)
inc += (avg + 1) - alth[k];
else
red += alth[k] - (avg + 1);
assert(red == 0 || inc == 0);
ans = min(ans, steps * m + inc * a + red * r);
ans = min(ans, (pref[n - 1] - n * h[0]) * r);
ans = min(ans, (n * h[n - 1] - pref[n]) * a);
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
static const int MAXN = 53;
static int n, m;
static bool a[MAXN][MAXN];
int main() {
scanf("%d%d", &n, &m);
getchar();
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= m; ++j) {
a[i][j] = (getchar() == '#');
}
}
for (int i = 0; i < n - 1; ++i) {
for (int j = i + 1; j < n; ++j) {
bool all_same = true, no_intersect = true;
for (int k = 0; k < m; ++k) {
if (a[i][k] != a[j][k]) {
all_same = false;
}
if (a[i][k] && a[j][k]) {
no_intersect = false;
}
}
if (!all_same && !no_intersect) {
puts("No");
return 0;
}
}
}
puts("Yes");
return 0;
}
| 1 |
#include<cstdio>
#include<ctime>
#include<iostream>
using namespace std;
const int md=924844033;
long long dp[2010];
int a[2010];
bool vis[2010];
int f[2010][2010][2];
long long fac[2010];
int n,k;
int main(){
// freopen("c.in","r",stdin);
// freopen("c.out","w",stdout);
scanf("%d%d",&n,&k);
fac[0]=1;
for(int i=1;i<=2000;i++)
fac[i]=fac[i-1]*i%md;
int p,cnt1,cnt2;
f[1][0][0]=1;
f[1][1][1]=1;
for(int i=2;i<=2000;i++)
{
for(int j=0;j<=i;j++)
{
if(j>0)
f[i][j][1]=f[i-1][j-1][0]%md;
f[i][j][0]=(f[i-1][j][1]+f[i-1][j][0])%md;
}
}
dp[0]=1;
for(int i=1;i<=n;i++){
if(!vis[i]){
cnt1=cnt2=0;
p=i;
vis[p]=1;
if(i-k>0) cnt1++;
while(p+2*k<=n){
cnt1++,cnt2++;
p=p+k*2;
vis[p]=1;
}
if(p+k<=n) cnt2++;
cnt1=cnt1+cnt2;
for(int j=0;j<=cnt1;j++)
a[j]=(f[cnt1][j][1]+f[cnt1][j][0])%md;
for(int j=n;j>=0;j--)
for(int s=1;s<=cnt1&&s<=j;s++)
dp[j]=(dp[j]+dp[j-s]*a[s])%md;
}
}
long long ans=0;
for(int i=0;i<=n;i++)
ans=(ans+fac[n-i]*dp[i]%md*((i&1)?-1:1)+md)%md;
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long pow2[128], sum, csum;
char cline[1024];
int main() {
sum = 0;
scanf("%s", cline);
N = strlen(cline);
pow2[0] = 1;
for (int i = 1; i < 128; i++) pow2[i] = (pow2[i - 1] * 2) % 1000000007;
for (int i = 0; i < N; i++) {
if (cline[i] == '1') {
int after = N - i - 1;
int before = i;
csum = pow2[before];
csum = (csum * pow2[after]) % 1000000007;
csum = (csum * pow2[after]) % 1000000007;
sum = (sum + csum) % 1000000007;
}
}
printf("%d\n", (int)(sum % 1000000007));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, x;
vector<pair<int, int>> v, w;
bool xd(pair<int, int> a, pair<int, int> b) {
return a.first + a.second > b.first + b.second;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
if (b >= 0)
v.push_back({a, b});
else
w.push_back({a, b});
}
sort(v.begin(), v.end());
for (auto it : v) {
if (it.first > k) {
cout << "NO";
return 0;
} else
k += it.second;
}
for (auto it : w) x -= it.second;
if (x > k) {
cout << "NO";
return 0;
}
sort(w.begin(), w.end(), xd);
for (auto it : w) {
if (it.first > k) {
cout << "NO";
return 0;
}
k += it.second;
if (k < 0) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[110][110];
bool b[110][110];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
memset(b, 1, sizeof(b));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 1) {
continue;
} else {
for (int k = 1; k <= n; k++) {
b[k][j] = 0;
}
for (int k = 1; k <= m; k++) {
b[i][k] = 0;
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j]) {
bool flag = 0;
for (int k = 1; k <= n; k++) {
if (b[k][j]) {
flag = 1;
break;
}
}
for (int k = 1; k <= m; k++) {
if (b[i][k] && !flag) {
flag = 1;
break;
}
}
if (flag == 0) {
printf("NO");
return 0;
}
}
}
}
printf("YES\n");
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << b[i][j] << " ";
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ans[60];
int main(void) {
int N, i;
long long K;
cin >> N >> K;
K--;
int L = 0, R = N;
long long two = (1ll << (N - 1));
for ((i) = 0; (i) < (int)(N); (i)++) {
if (K < two / 2) {
ans[L] = i;
L++;
} else {
ans[R - 1] = i;
R--;
K -= two / 2;
}
two /= 2;
}
for ((i) = 0; (i) < (int)(N); (i)++) {
cout << ans[i] + 1;
if (i == N - 1)
cout << endl;
else
cout << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Way[4][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
const double pi = acos(0.0) * 2;
const int INF = 1000000000;
const int N = 1000000 + 10;
int a[N], b[N], f[N], Ans, n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
Ans = 1;
for (int i = 1; i <= n; i++) {
f[i] = 1;
if (b[a[i]]) f[i] = max(f[i], b[a[i]] + 1);
Ans = max(f[i], Ans);
for (int Now = a[i]; Now <= 1000000; Now += a[i]) {
if (f[i] > b[Now]) b[Now] = f[i];
}
}
printf("%d\n", Ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int arr[n + 1];
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
long long int mini = 1000000000;
long long int maxi = 0;
for (long long int i = 0; i < n; i++) {
if (i < n - 1 && arr[i] == -1 && arr[i + 1] != -1) {
mini = min(mini, arr[i + 1]);
maxi = max(maxi, arr[i + 1]);
}
if (i > 0 && arr[i] == -1 && arr[i - 1] != -1) {
mini = min(mini, arr[i - 1]);
maxi = max(maxi, arr[i - 1]);
}
}
long long int k = (mini + maxi) / 2;
long long int ans = -111111111;
for (int i = 0; i < n; i++) {
if (arr[i] == -1) {
arr[i] = k;
}
}
for (int i = 0; i < n - 1; i++) {
ans = max(ans, abs(arr[i + 1] - arr[i]));
}
cout << ans << " " << k << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long a) { return a * a; }
long long ints[110][110], dp[110][110];
int main() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
for (long long j = 0; j < k; j++) {
long long l, r;
cin >> l >> r;
ints[l][r] += 1;
}
}
for (long long i = 2; i < m + 1; i++)
for (long long j = i - 1; j >= 1; j--)
ints[j][i] += ints[j + 1][i] + ints[j][i - 1] - ints[j + 1][i - 1];
for (long long i = 1; i < m + 1; i++)
for (long long j = i + 1 - 1; j >= 1; j--)
for (long long k = j; k < i + 1; k++) {
dp[j][i] = max(dp[j][i],
dp[j][k - 1] +
sqr(ints[j][i] - ints[j][k - 1] - ints[k + 1][i]) +
dp[k + 1][i]);
}
cout << dp[1][m] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400 + 10;
int ups[maxn][maxn], lf[maxn][maxn];
int zx[maxn][maxn], yx[maxn][maxn], n, m;
char a[maxn][maxn];
void Init() {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
ups[i][j] = ups[i - 1][j] + a[i][j] - '0';
lf[i][j] = lf[i][j - 1] + a[i][j] - '0';
zx[i][j] = zx[i - 1][j - 1] + a[i][j] - '0';
}
for (int j = m; j >= 1; --j) yx[i][j] = yx[i - 1][j + 1] + a[i][j] - '0';
}
}
inline bool check(int x, int y) { return x >= 1 && x <= n && y >= 1 && y <= m; }
int solve() {
int sum = 0, x, x2, y, y2;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
for (int k = 1; k <= min(n, m); ++k) {
x = i - k;
y = j - k;
if (check(x, y))
if (!(lf[i][j] - lf[i][y - 1] || ups[i][j] - ups[x - 1][j] ||
yx[i][y] - yx[x - 1][j + 1]))
sum++;
x = i - k;
y = j + k;
if (check(x, y))
if (!(lf[i][y] - lf[i][j - 1] || ups[i][j] - ups[x - 1][j] ||
zx[i][y] - zx[x - 1][j - 1]))
sum++;
x = i + k;
y = j + k;
if (check(x, y))
if (!(lf[i][y] - lf[i][j - 1] || ups[x][j] - ups[i - 1][j] ||
yx[x][j] - yx[i - 1][y + 1]))
sum++;
x = i + k;
y = j - k;
if (check(x, y))
if (!(lf[i][j] - lf[i][y - 1] || ups[x][j] - ups[i - 1][j] ||
zx[x][j] - zx[i - 1][y - 1]))
sum++;
x = i - k;
y = j - k;
y2 = j + k;
if (check(x, y) && check(x, y2))
if (!(lf[x][y2] - lf[x][y - 1] || zx[i][j] - zx[x - 1][y - 1] ||
yx[i][j] - yx[x - 1][y2 + 1]))
sum++;
x = i - k;
x2 = i + k;
y = j + k;
if (check(x, y) && check(x2, y))
if (!(ups[x2][y] - ups[x - 1][y] || yx[i][j] - yx[x - 1][y + 1] ||
zx[x2][y] - zx[i - 1][j - 1]))
sum++;
x = i + k;
y = j - k;
y2 = j + k;
if (check(x, y) && check(x, y2))
if (!(lf[x][y2] - lf[x][y - 1] || yx[x][y] - yx[i - 1][j + 1] ||
zx[x][y2] - zx[i - 1][j - 1]))
sum++;
x = i - k;
x2 = i + k;
y = j - k;
if (check(x, y) && check(x2, y))
if (!(ups[x2][y] - ups[x - 1][y] || zx[i][j] - zx[x - 1][y - 1] ||
yx[x2][y] - yx[i - 1][j + 1]))
sum++;
}
}
return sum;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%s", (a[i] + 1));
Init();
int ans = solve();
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr int MAXN = 2e5 + 1;
using ll = long long;
int N, M, K;
bool is[100];
void Solution() {
is[1] = is[7] = is[9] = 1;
if (((N > 9 && N < 30) || is[N / 10] || is[N % 10]) && N != 12)
cout << "NO\n";
else
cout << "YES\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
while (cin >> N) {
Solution();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
long long l, r;
scanf(" %lld %lld", &l, &r);
for (int i = 59; i >= 0; i--)
if ((r >> i) ^ (l >> i)) {
printf("%lld\n", (1LL << (i + 1)) - 1);
return 0;
}
printf("0\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int l, r, m;
int main() {
cin >> s;
while (s.size() != 3 && s.size() != 7) {
l = 0, r = 1;
do {
cout << "? " << l << " " << r << endl;
cin >> s;
if (s == "y") l = r, r <<= 1;
} while (s == "y");
while (l + 1 < r) {
m = (l + r) / 2;
cout << "? " << l << " " << m << endl;
cin >> s;
if (s == "y")
l = m;
else
r = m;
}
cout << "! " << l + 1 << endl;
cin >> s;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long> dp(n + 1, 100000000000);
vector<long long> rdp(n, 0);
vector<long long> ldp(n, 0);
rdp[n - 1] = 1;
ldp[0] = 1;
for (long long i = 1; i < n; i++) {
ldp[i] = min(ldp[i - 1] + 1, a[i]);
}
for (long long i = n - 2; i >= 0; i--) {
rdp[i] = min(rdp[i + 1] + 1, a[i]);
}
for (long long i = 0; i < n; i++) {
dp[i] = min(min(ldp[i], rdp[i]), a[i]);
}
long long m = 0;
for (long long i = 0; i < n; i++) {
m = max(m, dp[i]);
}
cout << m << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n, y, i, j;
scanf("%d", &n);
map<int, int> m;
for (i = 0; i < n * n; ++i) {
scanf("%d", &y);
m[-y]++;
}
int v[1000];
int pos = n - 1;
for (map<int, int>::iterator it = m.begin(); it != m.end(); ++it) {
int x = -(it->first);
while (it->second) {
v[pos] = x;
--it->second;
for (i = pos + 1; i < n; ++i) m[-gcd(v[pos], v[i])] -= 2;
--pos;
}
}
for (i = 0; i < n; ++i) printf("%d ", v[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, inv_2 = (mod + 1) / 2;
void Inc(int &x, int y) { x += y, x -= x >= mod ? mod : 0; }
void Dec(int &x, int y) { x -= y, x += x < 0 ? mod : 0; }
int mul(int x, int y) { return 1LL * x * y % mod; }
const int N = 1 << 16;
void fwt_and(vector<int> &f, int type) {
for (int mid = 1; mid < N; mid <<= 1)
for (int j = 0; j < N; j += (mid << 1))
for (int k = 0; k < mid; k++)
if (type == 1)
Inc(f[j + k], f[j + k + mid]);
else
Dec(f[j + k], f[j + k + mid]);
}
void fwt_or(vector<int> &f, int type) {
for (int mid = 1; mid < N; mid <<= 1)
for (int j = 0; j < N; j += (mid << 1))
for (int k = 0; k < mid; k++)
if (type == 1)
Inc(f[j + k + mid], f[j + k]);
else
Dec(f[j + k + mid], f[j + k]);
}
vector<int> dp[818], tmp_1, tmp_2;
int node_cnt = 0;
void dfs(int &x, string str) {
if (!x) x = ++node_cnt;
vector<int> &now = dp[x];
now.resize(N, 0);
if ((int)str.size() == 1) {
for (int i = 0; i < 4; i++) {
if (str[0] == '?' || str[0] == 'A' + i) {
int sta = 0;
for (int t = 0; t < 16; t++) sta |= ((t >> i) & 1) << t;
now[sta]++;
}
}
for (int i = 0; i < 4; i++) {
if (str[0] == '?' || str[0] == 'a' + i) {
int sta = 0;
for (int t = 0; t < 16; t++) sta |= (((t >> i) & 1) ^ 1) << t;
now[sta]++;
}
}
return;
}
int ls = 0, rs = 0, pos = -1, len = str.size();
for (int i = 0, sum = 0; i < len; i++) {
if (str[i] == '(') sum++;
if (str[i] == ')') sum--;
if (sum == 0) {
pos = i + 1;
break;
}
}
dfs(ls, str.substr(1, pos - 2));
dfs(rs, str.substr(pos + 2, len - pos - 3));
if (str[pos] == '&' || str[pos] == '?') {
tmp_1 = dp[ls], tmp_2 = dp[rs];
fwt_and(tmp_1, 1), fwt_and(tmp_2, 1);
for (int i = 0; i < N; i++) tmp_1[i] = mul(tmp_1[i], tmp_2[i]);
fwt_and(tmp_1, -1);
for (int i = 0; i < N; i++) Inc(now[i], tmp_1[i]);
}
if (str[pos] == '|' || str[pos] == '?') {
tmp_1 = dp[ls], tmp_2 = dp[rs];
fwt_or(tmp_1, 1), fwt_or(tmp_2, 1);
for (int i = 0; i < N; i++) tmp_1[i] = mul(tmp_1[i], tmp_2[i]);
fwt_or(tmp_1, -1);
for (int i = 0; i < N; i++) Inc(now[i], tmp_1[i]);
}
}
int Ans, T, root;
int Sta[20], Res[20];
string input;
int main() {
cin >> input >> T;
dfs(root, input);
for (int i = 1, A, B, C, D; i <= T; i++) {
cin >> A >> B >> C >> D >> Res[i];
Sta[i] = (A << 0) | (B << 1) | (C << 2) | (D << 3);
}
for (int S = 0; S < N; S++) {
int flag = 1;
for (int i = 1; i <= T && flag; i++)
if (((S >> Sta[i]) & 1) != Res[i]) flag = 0;
if (flag) Inc(Ans, dp[root][S]);
}
printf("%d\n", Ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int inf = 1e9;
const int N = 2e5 + 10;
int n, m, cnt;
int a[N], ans[N];
map<int, int> mp;
set<int> st;
vector<int> v;
long long sum = 0, p;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
st.insert(a[i]);
mp[a[i]] = 1;
}
sort(a + 1, a + 1 + n);
int j = 1;
for (j = 1;; j++) {
bool f = 0;
int y = 0;
for (auto x : st) {
if (mp[x - j] && mp[x + j]) {
v.push_back(x);
continue;
}
f = 0;
if (!mp[x - j]) {
cnt++;
mp[x - j] = 1;
ans[cnt] = x - j;
sum += j;
}
if (!mp[x + j]) {
cnt++;
mp[x + j] = 1;
ans[cnt] = x + j;
sum += j;
}
y = x;
if (cnt > m) {
sum -= j;
break;
}
if (cnt == m) break;
}
for (auto x : v) st.erase(x);
v.clear();
if (cnt >= m || st.size() == 0) break;
}
cout << sum << "\n";
for (int i = 1; i <= m; i++) cout << ans[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int v;
int no;
int top;
} qun[49];
int ji[49];
int q[1009];
int cmp(data a, data b) {
if (a.v == b.v) return a.no < b.no;
return a.v > b.v;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int i, j;
for (i = 0; i < m; i++) {
scanf("%d", &qun[i].v);
qun[i].no = i;
qun[i].top = -1;
}
int add = 0;
sort(&qun[0], &qun[m], cmp);
qun[0].v--;
qun[0].top = 0;
q[add] = qun[0].no;
add++;
bool xia = 0;
for (i = 1; i < n; i++) {
bool su = 0;
sort(&qun[0], &qun[m], cmp);
if (i + 1 != n)
for (j = 0; j < m; j++) {
if (qun[j].no == q[0]) {
if ((i - qun[j].top) != 1 && qun[j].v >= 1) {
qun[j].v--;
qun[j].top = i;
q[add] = qun[j].no;
add++;
su = 1;
break;
}
}
}
if (su == 0)
for (j = 0; j < m; j++) {
if (i + 1 == n && qun[j].no == q[0]) continue;
if ((i - qun[j].top) != 1 && qun[j].v >= 1) {
qun[j].v--;
qun[j].top = i;
q[add] = qun[j].no;
add++;
su = 1;
break;
}
}
if (su == 0) {
printf("-1\n");
xia = 1;
return 0;
}
}
for (i = 0; i < add; i++) {
printf("%d ", q[i] + 1);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, arr[1000009], j = 1, m;
memset(arr, 0, sizeof arr);
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
for (int k = 0; k < a; k++) {
arr[j++] = i;
}
}
cin >> m;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
cout << arr[a] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 2e5 + 5;
const long long INF = 1e15 + 5;
const long long MOD = 1e9 + 7;
const long long N = 1e5 + 5;
const double PI = 3.14159265358979323846264338327950288419716939937510;
long long n, m, flag, l[105], r[105], b[105], c[105];
vector<long long> adj[M];
void dfs(long long i) {
b[i] = 1;
for (auto x : adj[i]) {
if (b[x]) {
if (c[x] != 3 - c[i]) flag = 1;
continue;
}
c[x] = 3 - c[i];
dfs(x);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= m; i++) {
cin >> l[i] >> r[i];
if (l[i] > r[i]) swap(l[i], r[i]);
}
for (long long i = 1; i <= m; i++) {
for (long long j = 1; j <= m; j++) {
if (l[j] > l[i] && l[j] < r[i] && r[j] > r[i])
adj[i].push_back(j), adj[j].push_back(i);
}
}
for (long long i = 1; i <= m; i++)
if (!b[i]) c[i] = 1, dfs(i);
if (flag)
cout << "Impossible\n";
else {
for (long long i = 1; i <= m; i++) {
if (c[i] == 1)
cout << "o";
else
cout << "i";
}
cout << "\n";
}
}
| 4 |
#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
#define ll long long
using namespace std;
ll bit[400010],a[200010],b[200010],p[100010],x[100010],y[100010],n,q,inv[300010],m;
vector<ll> v;
map<ll,ll> mp;
ll sum(ll i){
ll s = 0;
while(i>0){
s += bit[i];
i -= i&-i;
}
return s;
}
void add(ll i, ll x){
while(i<=m){
bit[i] += x;
i += i&-i;
}
}
int main(){
ll z,ans=0,i;
cin >> n >> q;
for(i=0;i<2*n;i++){
cin >> a[i];
}
for(i=0;i<2*n;i++){
cin >> b[i];
}
for(i=1;i<2*n-1;i++){
v.push_back(a[i]-b[i]);
}
for(i=0;i<q;i++){
cin >> p[i] ;
p[i]--;
cin>> x[i] >> y[i];
if(p[i]!=0 && p[i]!=2*n-1){
v.push_back(x[i]-y[i]);
}
}
v.push_back(0);
sort(v.begin(),v.end());
m = v.size()+1;
int now = 1;
mp[v[0]] = 1;
inv[1] = v[0];
if(v[0]==0){
z = 1;
}
for(i=1;i<v.size();i++){
if(v[i]>v[i-1]){
now++;
}
mp[v[i]] = now;
inv[now] = v[i];
if(v[i]==0){
z = now;
}
}
now++;
ll cnt = 0;
for(i=1;i<2*n-1;i++){
add(mp[a[i]-b[i]],1);
if(a[i]>=b[i]){
ans += a[i];
cnt += 1;
}else{
ans += b[i];
}
}
ans += a[0]+a[2*n-1];
for(i=0;i<q;i++){
if(p[i]==0 || p[i]==2*n-1){
ans -= a[p[i]];
ans += x[i];
a[p[i]] = x[i];
b[p[i]] = y[i];
}else{
ans -= max(a[p[i]],b[p[i]]);
ans += max(x[i],y[i]);
add(mp[a[p[i]] - b[p[i]]],-1);
add(mp[x[i] - y[i]],1);
if(a[p[i]]-b[p[i]]>0 ^ x[i]-y[i]>0){
cnt++;
}
a[p[i]] = x[i];
b[p[i]] = y[i];
}
if(cnt%2==0){
cout << ans << endl;
}else{
long long l=0,r=now,mid;
int s = sum(z);
while(r - l>1){
mid = (l+r)/2;
if(sum(mid)>=s+1){
r = mid;
}else{
l = mid;
}
}
long long m1 = inv[r];
l=0,r=now;
while(r - l>1){
mid = (l+r)/2;
if(sum(mid)<s){
l = mid;
}else{
r = mid;
}
}
long long m2 = inv[r];
cout << max(ans - m1,ans + m2) << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, p, w, d;
scanf("%lld%lld%lld%lld", &n, &p, &w, &d);
for (long long i = 0; i < d && i <= n && p - i * w >= 0; i++) {
if ((p - i * w) % d == 0) {
long long k = min((n - i) / d, (p - i * w) / (w * d));
long long x = i + k * d;
long long y = (p - x * w) / d;
if (x + y <= n) {
printf("%lld %lld %lld\n", x, y, n - x - y);
return 0;
}
}
}
printf("-1\n");
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const long long mod = 1000000007LL;
int main(){
long long n;
cin >> n;
long long a = 1;
long long b = 1;
long long c = 1;
for(long long i = 1;i <= n;i++){
a = a *10 % mod;
b =b * 9 % mod;
c =c * 8 % mod;
}
cout << ((a - 2 * b + c) % mod + mod) % mod << endl;
} | 0 |
#include <iostream>
using namespace std;
int main() {
int k;
cin>>k;
cout<<k/2*(k-k/2)<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<set<int> > g;
vector<set<int> > leaves;
struct comp {
bool operator()(int a, int b) const {
if (leaves[a].size() == leaves[b].size()) return a < b;
return leaves[a].size() > leaves[b].size();
}
};
int main() {
int t;
cin >> t;
while (t--) {
cin >> n >> k;
g = leaves = vector<set<int> >(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
g[x].insert(y);
g[y].insert(x);
}
for (int i = 0; i < n; i++) {
if (g[i].size() == 1) {
leaves[*g[i].begin()].insert(i);
}
}
set<int, comp> st;
for (int i = 0; i < n; i++) {
st.insert(i);
}
int ans = 0;
while (1) {
int v = *st.begin();
if (int(leaves[v].size()) < k) break;
for (int i = 0; i < k; i++) {
int leaf = *leaves[v].begin();
g[leaf].erase(v);
g[v].erase(leaf);
st.erase(v);
st.erase(leaf);
leaves[v].erase(leaf);
if (leaves[leaf].count(v)) leaves[leaf].erase(v);
if (g[v].size() == 1) {
int to = *g[v].begin();
st.erase(to);
leaves[to].insert(v);
st.insert(to);
}
st.insert(v);
st.insert(leaf);
}
ans++;
}
cout << ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, ll, rr, dd, ans = 0, vv;
void init() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> dd >> vv >> ll >> rr;
ans = dd / vv;
ans = ans - (rr / vv - (ll - 1) / vv);
cout << ans << endl;
}
}
int main() {
init();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x[200005], y[200005];
int sgn[200005];
int par[200005];
vector<int> g[200005];
bool check(int a, int b, long long th) {
int icap = x[a] + x[b];
int jcap = y[a] + y[b];
long long z = 1LL * icap * icap + 1LL * jcap * jcap;
return (z <= th);
}
bool checkR(int a, int b, long long th) {
int icap = x[a] - x[b];
int jcap = y[a] - y[b];
long long z = 1LL * icap * icap + 1LL * jcap * jcap;
return (z <= th);
}
void dfs(int x, int p) {
sgn[x] *= sgn[p];
for (auto i : g[x]) {
if (i != p) dfs(i, x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
cin >> x[i] >> y[i];
}
vector<int> v;
for (int i = 1; i < n + 1; i++) {
v.push_back(i);
}
for (int i = 0; i < 200005; i++) {
sgn[i] = 1;
}
int id = n;
while (v.size() > 2) {
int u[3];
u[0] = v.back();
v.pop_back();
u[1] = v.back();
v.pop_back();
u[2] = v.back();
v.pop_back();
bool flag = 0;
for (int i = 0; i < 3; i++) {
for (int j = i + 1; j < 3; j++) {
if (check(u[i], u[j], 1e12)) {
par[u[i]] = par[u[j]] = ++id;
g[id].push_back(u[i]);
g[id].push_back(u[j]);
x[id] = x[u[i]] + x[u[j]];
y[id] = y[u[i]] + y[u[j]];
v.push_back(id);
for (int k = 0; k < 3; k++) {
if (k != i && k != j) v.push_back(u[k]);
}
flag = 1;
} else if (checkR(u[i], u[j], 1e12)) {
par[u[i]] = par[u[j]] = ++id;
g[id].push_back(u[i]);
g[id].push_back(u[j]);
x[id] = x[u[i]] - x[u[j]];
y[id] = y[u[i]] - y[u[j]];
sgn[u[j]] = -1;
v.push_back(id);
for (int k = 0; k < 3; k++) {
if (k != i && k != j) v.push_back(u[k]);
}
flag = 1;
}
if (flag == 1) break;
}
if (flag) break;
}
assert(flag);
}
++id;
g[id].push_back(v[0]);
g[id].push_back(v[1]);
if (check(v[0], v[1], 2.26 * 1e12) == 0) {
sgn[v[1]] = -1;
}
dfs(id, 0);
int ansx = 0, ansy = 0;
for (int i = 1; i < n + 1; i++) {
ansx += x[i] * sgn[i];
ansy += y[i] * sgn[i];
cout << sgn[i] << " ";
}
}
| 3 |
#include<cstdio>
#define LL long long
int t;
LL a,b,c,d;
LL gcd(LL a,LL b)
{
if(!b) return a;
return gcd(b,a%b);
}
int main()
{
scanf("%d",&t);
while(t--)
{
scanf("%lld%lld%lld%lld",&a,&b,&c,&d);
if(a<b) printf("No\n");
else if(d<b) printf("No\n");
else if(c>=b) printf("Yes\n");
else if(b-gcd(b,d)+a%gcd(b,d)>c) printf("No\n");
else printf("Yes\n");
//printf(" %lld %lld %lld\n",b,gcd(b,d),(c-a%b+b)%b);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5 + 1e5, MOD = 7 + 1e9;
typedef struct node {
int hp, ak, df;
} node;
node y, m;
bool ok(int i, int j, int k) {
node a;
a.hp = i + y.hp, a.ak = j + y.ak, a.df = k + y.df;
int dt = max(0, m.ak - a.df), dt1 = max(0, a.ak - m.df);
if (dt1 == 0) return 0;
int sd = (m.hp % dt1 == 0 ? m.hp / dt1 : (m.hp / dt1 + 1));
if (a.hp > sd * dt)
return 1;
else
return 0;
}
int main() {
scanf("%d%d%d", &y.hp, &y.ak, &y.df);
scanf("%d%d%d", &m.hp, &m.ak, &m.df);
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
int ans = 2e9;
for (int i = 0; i <= 2005; i++) {
for (int j = 0; j <= 205; j++) {
for (int k = 0; k <= 205; k++)
if (ok(i, j, k)) {
ans = min(ans, i * a + j * b + c * k);
break;
}
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int k;
cin >> k;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int mx = k;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j <= n - 1; j++) {
int d = k / arr[i];
int r = k % arr[i];
mx = max(r + d * arr[j], mx);
}
}
cout << mx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const signed int inf = (signed)(~0u >> 1);
const signed int llf = (signed int)(~0ull >> 1);
template <typename T>
inline void readInteger(T& u) {
static char x;
while (!isdigit(x = getchar()))
;
for (u = x - '0'; isdigit(x = getchar()); u = u * 10 + x - '0')
;
}
template <typename T>
class Matrix {
public:
T* p;
int row;
int col;
Matrix() : p(NULL) {}
Matrix(int row, int col) : row(row), col(col) { p = new T[(row * col)]; }
T* operator[](int pos) { return p + (pos * col); }
};
typedef class Edge {
public:
int u;
int v;
int w;
bool seced;
int rid;
Edge(int u = 0, int v = 0, int w = 0) : u(u), v(v), w(w), seced(false) {}
bool operator<(Edge b) const { return w < b.w; }
} Edge;
typedef class Node {
public:
int val;
Node* nxt[2];
Node(int val = inf) : val(val) { nxt[0] = nxt[1] = NULL; }
} Node;
typedef pair<Node*, Node*> pnn;
Node pool[2000000];
Node* top = pool;
Node* newnode(int x) {
if (top == pool + 2000000) return new Node(x);
*top = Node(x);
return top++;
}
Node* merge(Node*& l, Node* r) {
if (l == NULL) return r;
if (r == NULL) return l;
if (l->val > r->val) swap(l, r);
int p = rand() % 2;
l->nxt[p] = merge(l->nxt[p], r);
return l;
}
int n, m;
Edge* edge;
int* res;
int* ans;
inline void init() {
readInteger(n);
readInteger(m);
edge = new Edge[(m + 1)];
for (int i = 1; i <= m; i++) {
readInteger(edge[i].u);
readInteger(edge[i].v);
readInteger(edge[i].w);
edge[i].rid = i;
}
}
int* f;
int find(int x) { return (f[x] != x) ? (f[x] = find(f[x])) : (x); }
vector<int>* g;
vector<int>* add;
vector<int>* del;
inline void Kruskal() {
f = new int[(n + 1)];
g = new vector<int>[(n + 1)];
for (int i = 1; i <= n; i++) f[i] = i;
sort(edge + 1, edge + m + 1);
int fin = 0;
for (int i = 1; i <= m && fin < n - 1; i++) {
if (find(edge[i].u) != find(edge[i].v)) {
f[find(edge[i].u)] = find(edge[i].v);
g[edge[i].u].push_back(i);
g[edge[i].v].push_back(i);
edge[i].seced = true;
fin++;
}
}
}
const int BZMAX = 18;
int* dep;
Matrix<int> bz;
Matrix<int> bzm;
void dfs1(int node, int fa, int lastv) {
dep[node] = dep[fa] + 1;
bz[node][0] = fa;
bzm[node][0] = lastv;
for (int i = 1; i < BZMAX; i++)
bz[node][i] = bz[bz[node][i - 1]][i - 1],
bzm[node][i] = max(bzm[node][i - 1], bzm[bz[node][i - 1]][i - 1]);
for (int i = 0; i < (signed)g[node].size(); i++) {
if (!edge[g[node][i]].seced) continue;
int e = (edge[g[node][i]].u == node) ? (edge[g[node][i]].v)
: (edge[g[node][i]].u);
if (e == fa) continue;
dfs1(e, node, edge[g[node][i]].w);
}
}
pair<int, int> lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int rtmax = 0;
int ca = dep[u] - dep[v];
for (int i = 0; i < BZMAX; i++)
if (ca & (1 << i)) {
rtmax = max(rtmax, bzm[u][i]);
u = bz[u][i];
}
if (u == v) return pair<int, int>(u, rtmax);
for (int i = BZMAX - 1; ~i; i--) {
if (bz[u][i] != bz[v][i]) {
rtmax = max(rtmax, bzm[u][i]);
rtmax = max(rtmax, bzm[v][i]);
u = bz[u][i];
v = bz[v][i];
}
}
rtmax = max(rtmax, bzm[u][0]);
rtmax = max(rtmax, bzm[v][0]);
return pair<int, int>(bz[u][0], rtmax);
}
pair<Node*, Node*> dfs2(int node, int fa, int tofa) {
Node* rt = NULL;
Node* dl = NULL;
for (int i = 0; i < (signed)g[node].size(); i++) {
if (!edge[g[node][i]].seced) continue;
int e = (edge[g[node][i]].u == node) ? (edge[g[node][i]].v)
: (edge[g[node][i]].u);
if (e == fa) continue;
pnn ap = dfs2(e, node, g[node][i]);
rt = merge(rt, ap.first);
dl = merge(dl, ap.second);
}
for (int i = 0; i < (signed)add[node].size(); i++)
rt = merge(rt, newnode(add[node][i]));
for (int i = 0; i < (signed)del[node].size(); i++)
dl = merge(dl, newnode(del[node][i]));
while (dl && rt->val == dl->val) {
rt = merge(rt->nxt[0], rt->nxt[1]);
rt = merge(rt->nxt[0], rt->nxt[1]);
dl = merge(dl->nxt[0], dl->nxt[1]);
}
res[tofa] = (!rt) ? (-1) : (rt->val);
return pnn(rt, dl);
}
inline void solve() {
res = new int[(m + 1)];
dep = new int[(n + 1)];
bz = Matrix<int>(n + 1, BZMAX);
bzm = Matrix<int>(n + 1, BZMAX);
dep[0] = 0;
for (int i = 0; i < BZMAX; i++) bz[0][i] = bzm[0][i] = 0;
dfs1(1, 0, 0);
add = new vector<int>[(n + 1)];
del = new vector<int>[(n + 1)];
for (int i = 1; i <= m; i++) {
if (edge[i].seced) {
res[i] = -2;
continue;
}
int u = edge[i].u, v = edge[i].v;
pair<int, int> l = lca(u, v);
res[i] = l.second;
}
ans = new int[(m + 1)];
for (int i = 1; i <= m; i++) ans[edge[i].rid] = res[i];
for (int i = 1; i <= m; i++) {
if (ans[i] != -2) {
printf("%d\n", (ans[i] != -1) ? (ans[i]) : (1000000000));
}
}
}
int main() {
srand(233);
init();
Kruskal();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int long long> v;
int long long n;
cin >> n;
if (n == 1) {
cout << 1 << endl;
return 0;
}
for (int long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
v.push_back(i);
}
}
if (n > 1) v.push_back(n);
if (v.size() == 1) {
cout << v[0];
} else
cout << 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, count = 1, i;
scanf("%d%d", &n, &c);
int arr[n];
for (i = 0; i < n; i++) scanf("%d", &arr[i]);
for (i = 1; i < n; i++) {
if (arr[i] - arr[i - 1] <= c)
count++;
else
count = 1;
}
printf("%d\n", count);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using i64 = long long;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, m;
std::cin >> n >> m;
std::vector<std::string> s(n);
for (int i = 0; i < n; i++) {
std::cin >> s[i];
}
int ans = 0;
std::vector<bool> less(n - 1);
for (int j = 0; j < m; j++) {
bool must = false;
for (int i = 0; i < n - 1; i++) {
if (s[i][j] > s[i + 1][j] && !less[i]) {
must = true;
}
}
if (must) {
ans++;
} else {
for (int i = 0; i < n - 1; i++) {
if (s[i][j] < s[i + 1][j]) {
less[i] = true;
}
}
}
}
std::cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int room[51];
double dp[51][51][51];
int m;
long long comb[60][60];
void count() {
for (int i = 0; i < 51; ++i) {
for (int j = 0; j < 51; ++j) {
if (j == 0)
comb[i][j] = 1;
else if (i == 0)
comb[i][j] = 0;
else
comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
}
}
}
double solve(int r, int s, int tot) {
if (r == m) {
if (s == 0) return tot;
return 0;
}
double p = 1;
double& ret = dp[r][s][tot];
if (fabs(ret + 1) > 1e-9) return ret;
ret = 0;
for (int i = 0; i <= s; ++i) {
int len = (i + room[r] - 1) / room[r];
ret += comb[s][i] * p * solve(r + 1, s - i, max(tot, len));
p /= m;
}
return ret;
}
int main() {
for (int i = 0; i < 51; ++i) {
for (int j = 0; j < 51; ++j) {
for (int k = 0; k < 51; ++k) dp[i][j][k] = -1;
}
}
int n;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> room[i];
}
count();
printf("%.12f\n", solve(0, n, 0));
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=3e5+10;
struct point{int l,r;}a[N];
int n,m,tot,ans,c[N];
vector<int>vec[N];
int sum(int x){int ret=0;while(x)ret+=c[x],x-=x&-x;return ret;}
void add(int x,int y){while(x<=n)c[x]+=y,x+=x&-x;}
int main()
{
scanf("%d%d",&m,&n);
for(int i=1;i<=m;i++)
{
scanf("%d%d",&a[i].l,&a[i].r);
if(a[i].l)vec[a[i].r-a[i].l+1].push_back(i);
}
tot=m;
for(int i=1;i<=n;i++)
{
ans=0;
for(int j=1;j<=n/i;j++)ans+=sum(i*j);
printf("%d\n",tot+ans);
for(auto j:vec[i])add(a[j].l,1),add(a[j].r+1,-1),tot--;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int main(){
int n, k;
scanf("%d%d", &n, &k);
long ans = 0;
for(int i = k; i <= n + 1; i++)
ans += (long)(n-i+1)*i + 1;
printf("%ld\n", ans % MOD);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > g[100001];
bool vis[100001];
int dis[100001];
int num[100001];
int fa[100001];
int n, m;
int use[100001];
vector<pair<pair<int, int>, int> > ans;
void spfa() {
queue<int> q;
q.push(1);
dis[1] = 0;
vis[1] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first, value = g[u][i].second;
if (dis[v] > dis[u] + 1 ||
(dis[v] == dis[u] + 1 && num[v] < num[u] + value)) {
dis[v] = dis[u] + 1;
num[v] = num[u] + value;
fa[v] = u;
if (!vis[v]) {
vis[v] = 1;
q.push(v);
}
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a].push_back(make_pair(b, c));
g[b].push_back(make_pair(a, c));
}
memset(dis, 63, sizeof(dis));
spfa();
for (int i = n; i != 1; i = fa[i]) use[i] = 1;
use[1] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j < g[i].size(); j++) {
if (i < g[i][j].first && (!use[i] || !use[g[i][j].first]) &&
g[i][j].second == 1)
ans.push_back(make_pair(make_pair(i, g[i][j].first), 0));
if (i < g[i][j].first && use[i] && use[g[i][j].first] &&
g[i][j].second == 0)
ans.push_back(make_pair(make_pair(i, g[i][j].first), 1));
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first.first << " " << ans[i].first.second << " "
<< ans[i].second << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long data[111111];
int main() {
int n;
while (cin >> n) {
long long e = 0, ans = 0;
for (int i = 0; i != n; i++) {
int tmp;
cin >> tmp;
while (e > 0) {
if ((tmp ^ data[e]) > ans) ans = (tmp ^ data[e]);
if (tmp > data[e])
e--;
else
break;
}
data[++e] = tmp;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
long long n, mn = 1000000000, ans;
int d[2010], deg[2010], e[2010][2010];
char s[2010];
bool check() {
for (int i = 1; i <= n; ++i) d[i] = deg[i];
sort(d + 1, d + n + 1);
int sum = 0;
for (int i = 1; i < n; ++i) {
sum += d[i];
if (sum == i * (i - 1) / 2) return false;
}
return true;
}
void work(int x) {
deg[x] = n - deg[x] - 1;
for (int i = 1; i <= n; ++i) {
if (i == x) continue;
deg[i] += e[x][i] - e[i][x];
e[x][i] ^= 1, e[i][x] ^= 1;
}
}
void dfs(int x, int cnt) {
if (cnt > mn) return;
if (x == n + 1) {
if (check()) {
if (cnt < mn)
mn = cnt, ans = 1;
else if (cnt == mn)
ans++;
}
return;
}
dfs(x + 1, cnt), work(x), dfs(x + 1, cnt + 1), work(x);
}
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
scanf("%s", s + 1);
for (int j = 1; j <= n; ++j) deg[i] += e[i][j] = s[j] - '0';
}
if (check()) {
puts("0 1");
return 0;
}
for (int i = 1; i <= n; ++i) work(i), ans += check(), work(i);
if (ans) {
printf("1 %lld", ans);
return 0;
}
dfs(1, 0);
if (!ans)
puts("-1");
else {
for (int i = 1; i <= mn; ++i) ans = ans * i % 998244353;
printf("%lld %lld", mn, ans);
}
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.