solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 1000 + 1;
vector<int> ng[MAXN];
bool mark[MAXN];
vector<int> comps[MAXN];
void dfs(int x, int id) {
mark[x] = true;
comps[id].push_back(x);
for (int i = 0; i < ng[x].size(); i++)
if (!mark[ng[x][i]]) dfs(ng[x][i], id);
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
ng[a].push_back(b);
ng[b].push_back(a);
}
int compCnt = 0, sum = 0;
for (int i = 0; i < n; i++)
if (!mark[i]) {
dfs(i, compCnt);
compCnt++;
}
int ones = 0;
for (int i = 0; i < compCnt; i++) sum += min(k, (int)comps[i].size());
if (k == 1)
cout << max(compCnt - 2, 0) << endl;
else
cout << max(0, compCnt - sum / 2 - 1) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int minimum(int &a, int &b) { return a < b ? a : b; }
int main() {
string str;
cin >> str;
int length = str.length();
vector<int> lower(length + 1, 0);
vector<int> upper(length + 1, 0);
for (int i = 0; i < length; i++)
if (str[i] >= 'A' && str[i] <= 'Z') upper[0]++;
lower[0] = 0;
for (int i = 1; i < length + 1; i++) {
if (str[i - 1] >= 'a' && str[i - 1] <= 'z') {
lower[i] = lower[i - 1] + 1;
upper[i] = upper[i - 1];
} else {
upper[i] = upper[i - 1] - 1;
lower[i] = lower[i - 1];
}
}
int min = INT_MAX;
for (int i = 0; i < length + 1; i++)
if ((lower[i] + upper[i]) < min) min = lower[i] + upper[i];
cout << min;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005, maxm = 100005, INF = 2000000000;
int a[maxn], b[maxm];
int BinSearch(int l, int r, int v, int &d) {
if (v < b[l]) {
d = b[l] - v;
return l;
}
if (v > b[r]) {
d = v - b[r];
return r;
}
while (l < r - 1) {
int mid = (l + r) / 2;
if (b[mid] <= v)
l = mid;
else
r = mid;
}
int dl = v - b[l], dr = b[r] - v;
if (dl < dr) {
d = dl;
return l;
} else {
d = dr;
return r;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < m; ++i) scanf("%d", &b[i]);
int l = 0, r = m - 1, d, ans = 0;
for (int i = 0; i < n; ++i) {
l = BinSearch(l, r, a[i], d);
if (d > ans) ans = d;
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int uz[4];
int main() {
string s;
int c;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] > 48 && s[i] < 52) {
uz[s[i] - 48]++;
}
}
c = uz[1];
int d = uz[2];
while (uz[1]) {
cout << 1;
uz[1]--;
if (uz[1] != 0) {
cout << "+";
}
}
if (uz[2] != 0 && c != 0) cout << "+";
while (uz[2]) {
cout << 2;
uz[2]--;
if (uz[2] != 0) {
cout << "+";
}
}
bool z = 0;
if (d != 0 || c != 0) z = 1;
if (uz[3] != 0 && z) cout << "+";
while (uz[3]) {
cout << 3;
uz[3]--;
if (uz[3] != 0) {
cout << "+";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a1[1000][1000];
int main() {
int n, m, o = 0, a;
scanf("%d", &n);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
scanf("%d", a1[i] + j);
if (i == j) o ^= a1[i][j];
}
scanf("%d", &m);
while (m--) {
scanf("%d", &a);
if (a == 3)
printf("%d", o);
else
scanf("%d", &a), o ^= 1;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string a, b, c;
int main() {
cin >> a >> b >> c;
if (a[1] == '<') swap(a[0], a[2]);
if (b[1] == '<') swap(b[0], b[2]);
if (c[1] == '<') swap(c[0], c[2]);
if (a[0] == b[0])
cout << c[2] << c[0] << a[0] << "\n";
else if (b[0] == c[0])
cout << a[2] << a[0] << b[0] << "\n";
else if (a[0] == c[0])
cout << b[2] << b[0] << c[0] << "\n";
else
cout << "Impossible\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ull unsigned long long int
#define ld long double
#define f(i,n) for(ll i=0;i<n;i++)
#define f1(i,n) for(ll i=1;i<=n;i++)
#define f11(i,a,n,b) for(ll i=a;i<=n;i+=b)
#define fa(x,m) for(auto x:m)
#define fa1(a) for( auto itr=a.begin();itr!=a.end();itr++)
#define o(n) cout<<n<<endl
#define speed ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define sp(n,val) cout<<fixed<<setprecision(n)<<val<<endl;
#define Tc ll t;cin>>t;while(t--)
#define yes cout<<"yes"<<"\n"
#define no cout<<"no"<<"\n"
#define No cout<<"No"<<"\n"
#define Yes cout<<"Yes"<<"\n"
#define NO cout<<"NO"<<"\n"
#define YES cout<<"YES"<<"\n"
#define vl vector<ll>
#define vp vector< pair<ll,ll>>
#define vs vector <string>
#define vc vector <char>
#define pb push_back
#define ppb(a,b) push_back(make_pair(a,b))
#define in(a,n); ll a[n]; for(ll i=0;i<n;i++) {cin>>a[i];}
#define out(a,n); for(ll i=0;i<n;i++) {cout<<a[i]<<" ";} cout<<endl;
#define mll map<ll,ll>
#define mcl map<char,ll>
#define msl map<string,ll>
#define ff first
#define ss second
#define pi 3.1415926535897932
#define all(a) (a).begin(), (a).end()
bool sortbyfir(const pair<int,int> &a , const pair<int,int> &b)
{
if(a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
bool sortbysec(const pair<int,int> &a,const pair<int,int> &b)
{
if(a.second==b.second) return b.first>a.first;
return (a.second < b.second);
}
bool compmx(int a, int b) {return (a < b);}
ll binaryToDecimal(string n)
{
string num = n;
ll dec_value = 0;
ll base = 1;
for (int i = num.length() - 1; i >= 0; i--) {
if (num[i] == '1')
dec_value += base;
base = base * 2;
}
return dec_value;
}
ll bin(ll n)
{
ll B_Number = 0;
ll c=1;
while (n != 0) {
ll rem = n % 2;
B_Number += rem * c;
c*=10;
n /= 2;
}
return B_Number;
}
ll gcd(ll a, ll b)
{
if (b == 0) return a;
else return gcd(b, a % b);
}
bool is_prime(ll x) {
if(x==1) return false;
if(x==2 || x==3) return true;
for(ll i=2;i*i<=x;i++)
{
if(x%i==0) return false;
}
return true;
}
ull fact(ull n)
{
if (n == 0) return 1;
return n * fact(n - 1);
}
int main()
{
speed;
Tc
{
ll n;
cin>>n;
ll x,y;
vl miner,mine;
f(i,2*n)
{
cin>>x>>y;
if(x==0) miner.pb(abs(y));
else mine.pb(abs(x));
}
sort(all(mine));
sort(all(miner));
ld ans=0;
f(i,n)
{
ans+= sqrt(1.0*(miner[i]*miner[i]+mine[i]*mine[i]));
}
cout << fixed << setprecision(10) << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
int n, m, k;
int a[200][200];
int ans[200], b[200];
vector<int> g[200];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> a[i][j];
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < 200; j++) g[j].clear();
for (int j = 0; j < n; j++)
if (a[j][i] && !ans[j]) {
g[a[j][i]].push_back(j);
}
for (int j = 1; j <= k; j++) {
if (g[j].size() == 1) {
int v = g[j][0];
if (b[j]) {
ans[v] = i + 1;
}
} else if (g[j].size() > 1) {
b[j] = 1;
for (int l = 0; l < g[j].size(); l++) ans[g[j][l]] = i + 1;
}
}
}
for (int i = 0; i < n; i++) cout << ans[i] << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2e5 + 5;
const int INF = 1e9 + 5;
class edge {
public:
int u, v, c, id;
void read(int i) {
scanf("%d%d%d", &u, &v, &c);
id = i;
}
bool operator<(const edge& o) const { return c < o.c; }
};
int n, m;
edge e[Maxn];
int ans[Maxn];
int pa[Maxn];
int dep[Maxn];
int maxw[Maxn][19];
int ancs[Maxn][19];
bool marked[Maxn];
int up[Maxn];
int minw[Maxn];
vector<pair<int, int> > adj[Maxn];
bool used[Maxn];
int find(int x) { return (x == pa[x]) ? x : pa[x] = find(pa[x]); }
bool uni(edge edg) {
int a = find(edg.u), b = find(edg.v);
if (a == b) return false;
pa[b] = a;
return true;
}
void mst() {
sort(e + 1, e + m + 1);
for (int i = 1; i <= m; i++) {
if (uni(e[i])) {
adj[e[i].u].push_back(pair<int, int>(e[i].v, e[i].c));
adj[e[i].v].push_back(pair<int, int>(e[i].u, e[i].c));
used[i] = true;
}
}
}
void dfs(int now, int pre = -1) {
for (auto v : adj[now]) {
if (v.first != pre) {
dep[v.first] = dep[now] + 1;
ancs[v.first][0] = now;
maxw[v.first][0] = v.second;
for (int i = 1; i <= 18; i++) {
ancs[v.first][i] = ancs[ancs[v.first][i - 1]][i - 1];
maxw[v.first][i] =
max(maxw[v.first][i - 1], maxw[ancs[v.first][i - 1]][i - 1]);
}
up[v.first] = now;
dfs(v.first, now);
}
}
}
void build() {
dep[1] = 0;
for (int i = 0; i <= 18; i++) {
ancs[1][i] = 1;
maxw[1][i] = 0;
}
dfs(1);
memset(minw, 0, sizeof minw);
memset(marked, 0, sizeof marked);
}
int mark(int src, int dst, int wgt) {
if (dep[src] <= dep[dst]) return src;
if (!marked[src]) {
marked[src] = true;
minw[src] = wgt;
}
return up[src] = mark(up[src], dst, wgt);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) pa[i] = i;
for (int i = 1; i <= m; i++) {
e[i].read(i);
}
mst();
build();
for (int i = 1; i <= m; i++) {
if (!used[i]) {
int u = e[i].u, v = e[i].v;
if (dep[u] < dep[v]) swap(u, v);
int w = 0;
for (int i = 18; i >= 0; i--) {
if ((1 << i) <= dep[u] - dep[v]) {
w = max(w, maxw[u][i]);
u = ancs[u][i];
}
}
for (int i = 18; i >= 0; i--) {
if (ancs[u][i] != ancs[v][i]) {
w = max(w, maxw[u][i]);
w = max(w, maxw[v][i]);
u = ancs[u][i];
v = ancs[v][i];
}
}
int lca = u;
if (u != v) {
w = max(w, maxw[u][0]);
w = max(w, maxw[v][0]);
lca = ancs[u][0];
}
ans[e[i].id] = w - 1;
u = e[i].u;
v = e[i].v;
mark(u, lca, e[i].c);
mark(v, lca, e[i].c);
}
}
for (int i = 1; i <= m; i++) {
if (used[i]) {
int u = e[i].u, v = e[i].v;
if (dep[u] < dep[v]) swap(u, v);
ans[e[i].id] = minw[u] - 1;
}
}
for (int i = 1; i <= m; i++) printf("%d ", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long getBit(long long x, long long i) { return (x >> i) & 1LL; }
bool esPalindromo(string &s) {
int n = s.size();
for (int i = 0; i <= n / 2; i++) {
if (s[i] != s[n - 1 - i]) return false;
}
return true;
}
int main() {
string s;
cin >> s;
long long n = s.size();
string res = "", aux;
for (long long mask = 0; mask < (1LL << n); mask++) {
aux = "";
for (int i = 0; i < n; i++) {
if (getBit(mask, i) == 1) {
aux += s[i];
}
}
if (esPalindromo(aux)) {
if (res < aux) res = aux;
}
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[1000005];
char *s1, *s2;
long long su1, su2;
int main() {
int l1, l2;
while (scanf("%s", s) != EOF) {
s1 = strtok(s, "^");
s2 = strtok(NULL, "^");
l1 = strlen(s1);
l2 = strlen(s2);
su1 = 0;
su2 = 0;
for (int i = 0; i < l1; i++) {
if (isdigit(s1[i])) {
su1 = su1 + (s1[i] - '0') * (l1 - i);
}
}
for (int i = 0; i < l2; i++) {
if (isdigit(s2[i])) {
su2 = su2 + (s2[i] - '0') * (i + 1);
}
}
if (su1 < su2) printf("right\n");
if (su1 == su2) printf("balance\n");
if (su1 > su2) printf("left\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
int arr[4] = {0};
for (int i = 0; i < 3; i++) {
cin >> s;
if (s[1] == '>')
arr[s[0] - 'A']++;
else
arr[s[2] - 'A']++;
}
if (arr[0] == arr[1] && arr[1] == arr[2])
return cout << "Impossible" << endl, 0;
char ss[3] = {""};
ss[arr[0]] = 'A';
ss[arr[1]] = 'B';
ss[arr[2]] = 'C';
cout << ss[0] << ss[1] << ss[2] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve(void) {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int res = 9999;
for (int i = 0; i < n - 1; i++) {
if (abs(arr[i] - arr[i + 1]) < res) {
res = abs(arr[i] - arr[i + 1]);
}
}
cout << res << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, a1, b1, c1;
int d, dx, dy;
int main() {
cin >> a >> b >> c;
cin >> a1 >> b1 >> c1;
if ((a == 0 && b == 0 && c != 0) || (a1 == 0 && b1 == 0 && c1 != 0))
cout << 0;
else {
d = (a * b1) - (a1 * b);
dx = (c * b1) - (c1 * b);
dy = (a * c1) - (a1 * c);
if (d != 0)
cout << 1;
else {
if (dx == 0 && dy == 0)
cout << -1;
else
cout << 0;
}
}
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int INF = 1 << 29;
const int MOD = 1e9 + 7;
bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); }
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
const int dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[] = {0, -1, 0, 1, 1, -1, -1, 1};
map<int, int> r1, c1;
int main() {
fastio();
int tc = 1;
while (tc--) {
int n, m, k;
cin >> n >> m >> k;
int a[n][m];
for (int i = 0; i < (n); i++) {
for (int j = 0; j < (m); j++) {
cin >> a[i][j];
c1[j] = j;
}
r1[i] = i;
}
while (k--) {
char c;
int x, y;
cin >> c >> x >> y;
x--, y--;
if (c == 'c') {
int u = c1[x], u1 = c1[y];
c1[y] = u;
c1[x] = u1;
} else if (c == 'r') {
int u = r1[x], u1 = r1[y];
r1[y] = u;
r1[x] = u1;
} else {
int u = r1[x], u1 = c1[y];
cout << a[u][u1];
cout << "\n";
;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y;
string s;
vector<long long> oneIndex;
long long dp[300001][2];
long long getResult(int index, int reverted) {
if (index == oneIndex.size() - 1) {
long long val = reverted != 0 ? y - x : 0;
return reverted != 0 ? y - x : 0;
}
if (dp[index][reverted] != -1) {
return dp[index][reverted];
}
long long ans = LLONG_MAX;
if (oneIndex[index + 1] - oneIndex[index] != 1) {
long long ans1 = getResult(index + 1, 1) + x;
long long ans2 = getResult(index + 1, 0) + y;
ans = min(ans1, ans2);
} else {
ans = getResult(index + 1, reverted);
}
dp[index][reverted] = ans;
return ans;
}
int main() {
cin >> n >> x >> y;
cin >> s;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
oneIndex.push_back(0);
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
oneIndex.push_back(i + 1);
}
}
memset(dp, -1, sizeof(dp));
oneIndex.push_back(n + 1);
cout << getResult(0, 0) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int t;
int n, m;
int a[maxn];
int main() {
scanf("%d", &t);
int o = 1;
while (t--) {
bool vis1[maxn] = {0}, vis2[maxn] = {0};
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
int mx1 = 0, len1 = 0;
int mx2 = 0, len2 = 0;
map<int, int> mp1, mp2;
mp1.clear();
mp2.clear();
for (int i = 1; i <= n; ++i) {
if (vis1[a[i]])
break;
else {
vis1[a[i]] = 1;
++len1;
mx1 = max(mx1, a[i]);
if (mx1 == len1) mp1[len1]++;
}
}
for (int i = n; i >= 1; --i) {
if (vis2[a[i]])
break;
else {
vis2[a[i]] = 1;
++len2;
mx2 = max(mx2, a[i]);
if (mx2 == len2) mp2[len2]++;
}
}
int ans = 0;
vector<int> v;
v.clear();
for (auto i : mp1) {
int j = i.first;
if (mp2.count(n - j)) {
v.push_back(j);
}
}
printf("%d\n", v.size());
for (int i : v) {
printf("%d %d\n", i, n - i);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, x, b[200005] = {0}, ans, ta, kk, kkk, ttt = 0;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> t;
for (int jjj = 0; jjj < t; jjj++) {
ta = 0;
ans = 0;
kk = 0;
kkk = 0;
cin >> n >> x;
if (x == 0) {
ta = 1;
}
for (int i = 0; i <= 2 * n; i++) {
b[i] = 0;
}
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
ans++;
b[ans + n]++;
} else {
ans--;
b[ans + n]++;
}
}
if (ans == 0) {
if (x <= n && x >= -n) {
if (b[x + n] != 0) {
cout << -1 << endl;
} else {
cout << ta << endl;
}
} else {
cout << ta << endl;
}
} else {
if (ans > 0) {
kk = (x + n) / ans;
kkk = (x - n - 1) / ans + 1;
if (x <= n) {
kkk = 0;
}
for (int i = kkk; i <= kk + 1; i++) {
if (x - i * ans + n >= 0 && x - i * ans + n <= 2 * n) {
ta = ta + b[x - i * ans + n];
}
}
cout << ta << endl;
}
if (ans < 0) {
kk = (n + x) / ans;
kkk = (x - n) / ans;
for (int i = max(kk - 1, ttt); i <= kkk + 1; i++) {
if (x - i * ans + n >= 0 && x - i * ans + n <= 2 * n) {
ta = ta + b[x - i * ans + n];
}
}
cout << ta << endl;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1;
const long long big = 1e18;
const long long block = 800;
const long long mod = 1e6;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long a;
cin >> a;
long long cur = 0;
bool cl = (a % 400 == 0 || (a % 4 == 0 && a % 100));
for (int i = 1; i < 1e5; i++) {
long long x = a + i;
bool hm = (x % 400 == 0 || (x % 4 == 0 && x % 100));
cur += 1 + hm;
if (hm == cl && cur % 7 == 0) {
cout << a + i;
exit(0);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int a[105], b[105];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll i, j;
string s;
cin >> s;
vector<int> pos;
for (i = 0, j = (int)s.size() - 1; i < j;) {
while (s[i] == ')') i++;
while (j >= 0 && s[j] == '(') j--;
if (i > j) break;
pos.push_back(i);
pos.push_back(j);
i++;
j--;
}
sort(pos.begin(), pos.end());
if (pos.empty()) return cout << 0, 0;
cout << "1\n" << pos.size() << '\n';
for (int x : pos) cout << x + 1 << ' ';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846;
const double E = 2.7182818284590452354;
const struct __ {
ios_base::Init i;
int s;
__() : s(ios_base::xalloc()) {
srand((unsigned)time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
} _;
inline ostream& operator<<(ostream& o, const __&) {
o.iword(_.s) = 0;
return o << '\n';
}
template <class T>
inline ostream& operator,(ostream& o, const T& x) {
if (o.iword(_.s))
o << ' ';
else
o.iword(_.s) = 1;
return o << x;
}
template <>
inline ostream& operator, <__>(ostream& o, const __&) {
return o << _;
}
template <class I>
inline void in(I A, I B) {
while (A != B) {
cin >> *A;
++A;
}
}
template <class I>
inline void out(I A, I B, char D = ' ') {
if (A != B) {
cout << *A;
while (++A != B) {
cout << D << *A;
}
}
cout << _;
}
template <class T>
inline T sq(const T& X) {
return X * X;
}
template <class T>
inline T power(T X, int Y) {
assert(Y >= 0 && !(X == 0 && Y == 0));
T R = (Y & 1) ? X : 1;
while (Y >>= 1) {
X *= X;
if (Y & 1) R *= X;
}
return R;
}
int main() {
int y, b, r;
cin >> y >> b >> r;
int k = 1;
while (k <= y && k + 1 <= b && k + 2 <= r) k++;
k--;
cout << 3 * k + 3 << _;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<double, pair<int, int> > > s;
int n, x;
pair<double, pair<int, int> > tmp;
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (register int i = 1; (1 < n) ? (i <= n) : (i >= n);
i += (1 < n) ? 1 : (-1)) {
cin >> x;
s.push_back(make_pair(x, make_pair(i, i)));
while (s.size() > 1 && s[s.size() - 2] > s.back()) {
tmp = s.back();
s.pop_back();
tmp = make_pair((tmp.first * (tmp.second.second - tmp.second.first + 1) +
s.back().first * (s.back().second.second -
s.back().second.first + 1)) /
(tmp.second.second - s.back().second.first + 1),
make_pair(s.back().second.first, tmp.second.second));
s.pop_back();
s.push_back(tmp);
}
}
for (auto i : s) {
for (register int j = 1; (1 < i.second.second - i.second.first + 1)
? (j <= i.second.second - i.second.first + 1)
: (j >= i.second.second - i.second.first + 1);
j += (1 < i.second.second - i.second.first + 1) ? 1 : (-1)) {
printf("%.9lf\n", i.first);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long arr[n + 1];
long long a, b, c;
vector<long long> A, B, common;
for (long long i = 0; i < n; i++) {
cin >> a >> b >> c;
if (b == 1 && c == 1) {
common.push_back(a);
} else if (b == 1) {
A.push_back(a);
} else if (c == 1) {
B.push_back(a);
}
}
sort(common.begin(), common.end());
sort(A.begin(), A.end());
sort(B.begin(), B.end());
long long pc = 0, pa = 0, pb = 0;
if ((long long)(common.size() + min(A.size(), B.size())) < k) {
cout << "-1\n";
return 0;
}
long long cnt = 0, res = 0;
common.push_back(INT_MAX);
A.push_back(INT_MAX);
B.push_back(INT_MAX);
while (pc < (long long)common.size() || (pa < A.size() && pb < B.size())) {
if (cnt == k) break;
if (common[pc] < A[pa] + B[pb]) {
res += common[pc];
pc++;
cnt++;
} else {
res += (A[pa] + B[pb]);
pa++;
pb++;
cnt++;
}
}
if (cnt == k)
cout << res;
else
cout << "-1";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
const int mod = 998244353;
vector<int> G[N];
bool vis[N];
int lvl[N], power2[N];
int ans;
void pre() {
power2[0] = 1;
for (int i = 1; i < N; i++) {
power2[i] = power2[i - 1] * 1ll * 2 % mod;
}
}
int power(int a, int b) {
int res = 1;
a %= mod;
while (b > 0) {
if (b & 1) {
res = res * 1ll * a % mod;
b--;
}
a = a * 1ll * a % mod;
b >>= 1;
}
return res;
}
bool checkBipartite(int rt) {
queue<int> bfs;
bfs.push(rt);
vis[rt] = true;
lvl[rt] = 0;
int odd = 0, even = 0;
while (!bfs.empty()) {
int u = bfs.front();
bfs.pop();
if (lvl[u] & 1)
odd++;
else
even++;
for (int v : G[u]) {
if (!vis[v]) {
bfs.push(v);
lvl[v] = lvl[u] + 1;
vis[v] = true;
} else if ((lvl[u] + 1) % 2 != lvl[v] % 2) {
return false;
}
}
}
ans = ans * 1ll * ((power2[odd] + power2[even]) % mod) % mod;
return true;
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
G[i].clear();
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
if (m == 0) {
cout << power(3, n) << '\n';
return;
}
memset(vis, false, sizeof(vis));
ans = 1;
for (int i = 1; i <= n; i++) {
if (!vis[i] && !checkBipartite(i)) {
cout << 0 << '\n';
return;
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
pre();
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long INF = 1e9, MOD = INF + 7;
long long gcd(long long a, long long b) { return (b ? gcd(b, a % b) : a); }
long long power(long long a, long long b) {
return (!b ? 1 : power(a, b / 2) * power(a, b / 2) * (b % 2 ? a : 1));
}
long long mod(long long a) { return (a % MOD + MOD) % MOD; }
const long long N = 1e2 + 20;
long long n, m;
char a[N][N];
bool mark[N][N];
long long dx[4] = {+1, -1, 0, 0};
long long dy[4] = {0, 0, -1, +1};
bool isVal(long long x, long long y) {
return (x >= 0 && y >= 0 && x < n && y < m);
}
bool couldUse(long long x, long long y, char c) {
for (long long k = 0; k < 4; k++) {
long long i = x + dx[k];
long long j = y + dy[k];
if (isVal(i, j) && a[i][j] == c) return false;
}
return true;
}
char getChar(long long x, long long y) {
for (char c = 'A'; c <= 'Z'; c++)
if (couldUse(x, y, c)) return c;
return '?';
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (long long x = 0; x < n; x++)
for (long long y = 0; y < m; y++) {
if (mark[x][y]) continue;
char c = getChar(x, y);
long long k = 0;
while (k < min(n - x, m - y) && !mark[x][y + k] && c == getChar(x, y + k))
k++;
for (long long i = x; i < x + k; i++)
for (long long j = y; j < y + k; j++) a[i][j] = c, mark[i][j] = true;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cout << a[i][j];
cout << "\n";
}
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define fr(a,b) for(long long int i=a;i<b;i++)
#define mod 1000000007
int main(){
ll t;
cin>>t;
while(t--){
ll n,x,sum1=0,sum2=0,ans=0;
cin>>n>>x;
vector<ll>arr(n);
fr(0,n){
cin>>arr[i];
double temp=(double)arr[i]/x;
ll k=ceil(temp);
ans+=k;
if(arr[i]%x!=0){
sum1+=arr[i];
}
else{
sum2+=arr[i];
}
}
double temp=(double)sum1/x;
double temp2=(double)sum2/x;
ll nums=ceil(temp)+ceil(temp2);
cout<<nums<<" "<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int A[500500];
bool Visited[500500];
int Ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
Ans = n;
sort(A, A + n);
reverse(A, A + n);
int i = 0, j = n >> 1;
while (j < n) {
if (Visited[i]) {
i++;
continue;
}
if (i == j) {
j++;
continue;
}
if (A[i] >> 1 >= A[j]) {
Ans--;
Visited[j] = true;
i++;
j++;
} else {
j++;
}
}
cout << Ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct rect {
int x1, y1, x2, y2;
} r[7];
int n, X[11], Y[11], Xn, Yn, c[11][11], mx2, my2, Mx2, My2;
int main() {
scanf("%d", &n);
mx2 = my2 = 999999;
Mx2 = My2 = -1;
for (int i = 1; i <= n; i++) {
scanf("%d%d%d%d", &r[i].x1, &r[i].y1, &r[i].x2, &r[i].y2);
X[++Xn] = r[i].x1;
X[++Xn] = r[i].x2;
Y[++Yn] = r[i].y1;
Y[++Yn] = r[i].y2;
if (mx2 > r[i].x1) mx2 = r[i].x1;
if (my2 > r[i].y1) my2 = r[i].y1;
if (Mx2 < r[i].x2) Mx2 = r[i].x2;
if (My2 < r[i].y2) My2 = r[i].y2;
}
sort(X + 1, X + Xn + 1);
sort(Y + 1, Y + Yn + 1);
int one = 0, mx, Mx, my, My;
mx = my = 999;
Mx = My = -1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= Xn; j++)
if (r[i].x1 == X[j]) {
r[i].x1 = j;
break;
}
for (int j = 1; j <= Xn; j++)
if (r[i].x2 == X[j]) {
r[i].x2 = j;
break;
}
for (int j = 1; j <= Yn; j++)
if (r[i].y1 == Y[j]) {
r[i].y1 = j;
break;
}
for (int j = 1; j <= Yn; j++)
if (r[i].y2 == Y[j]) {
r[i].y2 = j;
break;
}
for (int a = r[i].x1; a < r[i].x2; a++)
for (int b = r[i].y1; b < r[i].y2; b++) {
c[a][b] = 1, ++one;
if (mx > a) mx = a;
if (my > b) my = b;
if (Mx < a) Mx = a;
if (My < b) My = b;
}
}
if ((Mx - mx + 1) * (My - my + 1) == one && (Mx2 - mx2) == (My2 - my2))
puts("YES");
else
puts("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, k;
cin >> n >> k;
long long int aa[n];
vector<long long int> a;
long long int i;
for (i = 0; i < n; i++) cin >> aa[i], a.push_back(aa[i]);
if (k == 1) {
cout << n << endl;
exit(0);
}
sort(a.begin(), a.end());
set<long long int> s;
s.insert(a[0]);
long long int count = 1, l = 1;
count = 1;
l = 1;
long long int z, x, q, out = 0;
while (1) {
if (s.empty() == true) {
if (l >= a.size()) break;
s.insert(a[l]);
count++;
l++;
if (l >= a.size()) break;
}
z = *(s.begin());
s.erase(s.begin());
x = z * k;
auto qq = lower_bound(a.begin(), a.end(), x);
if (qq != a.end()) {
q = qq - a.begin();
for (i = l; i < q; i++) {
if (a[i] == x) {
break;
}
count++;
s.insert(a[i]);
}
if (a[q] == x) q++;
l = q;
} else {
count += a.size() - l;
break;
}
}
cout << count << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool val(int n, int mi, int k, int fedor) {
for (int i = 0; i < n; i++) {
if ((fedor & (1 << i)) != (mi & (1 << i))) k--;
if (k == -1) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<int> v;
int a;
for (int i = 0; i <= m; i++) {
cin >> a;
v.push_back(a);
}
int fedor = v[v.size() - 1];
int cont = 0;
for (int i = v.size() - 2; i >= 0; i--) {
if (val(n, v[i], k, fedor)) cont++;
}
cout << cont << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
if (n == 1)
puts("a\na\nb\nb");
else if (n % 2 == 0) {
for (int i = 0; i < n / 2; ++i)
printf("%c%c", 'a' + (i % 13), 'a' + (i % 13));
printf("\n%c", 'a' + 13);
for (int i = 0; i < n / 2 - 1; ++i)
printf("%c%c", 'a' + 15 + (i % 11), 'a' + 15 + (i % 11));
printf("%c", 'a' + 14);
printf("\n%c", 'a' + 13);
for (int i = 0; i < n / 2 - 1; ++i)
printf("%c%c", 'a' + (i % 13), 'a' + (i % 13));
printf("%c\n", 'a' + 14);
for (int i = 0; i < n / 2; ++i)
printf("%c%c", 'a' + 15 + (i % 11), 'a' + 15 + (i % 11));
} else {
for (int i = 0; i < n / 2; ++i)
printf("%c%c", 'a' + (i % 13), 'a' + (i % 13));
printf("%c\n", 'a' + 13);
for (int i = 0; i < n / 2; ++i)
printf("%c%c", 'a' + 15 + (i % 11), 'a' + 15 + (i % 11));
printf("%c\n", 'a' + 13);
printf("%c", 'a' + 14);
for (int i = 0; i < n / 2; ++i)
printf("%c%c", 'a' + (i % 13), 'a' + (i % 13));
printf("\n%c", 'a' + 14);
for (int i = 0; i < n / 2; ++i)
printf("%c%c", 'a' + 15 + (i % 11), 'a' + 15 + (i % 11));
puts("");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string buffer;
cin >> buffer;
int count = 0;
map<char, int> symbols;
bool found;
for (auto ch : buffer) {
found = false;
for (auto sym : symbols) {
if (sym.first == ch) {
symbols[ch]++;
found = true;
break;
}
}
if (found == false) {
symbols[ch] = 1;
count++;
if (count >= 5) {
cout << "No" << endl;
return 0;
}
}
}
if (count < 2) {
cout << "No" << endl;
return 0;
} else if (count == 2) {
for (auto sym : symbols) {
if (sym.second < 2) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} else if (count == 3) {
for (auto sym : symbols) {
if (sym.second >= 2) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
} else {
cout << "Yes" << endl;
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int T,n,p[100010],ls;
long long ans;
int main(){
scanf("%d",&T);
while(T--){
scanf("%d",&n),ls=n,ans=0;
for(int i=2;i<=(n>>1);++i)p[ls]=i,ans+=1ll*(n-i)*(n-i),ls=i;
p[ls]=1,ls=1;
for(int i=(n>>1)+1;i<=n;++i)p[ls]=i,ans+=1ll*(i-1)*(i-1),ls=i;
printf("%lld\n",ans);
for(int i=1;i<=n;++i)printf("%d%c",p[i]," \n"[i==n]);
printf("%d\n",n-1);
for(int i=2;i<=(n>>1);++i)printf("%d %d\n",i,n);
for(int i=(n>>1)+1;i<=n;++i)printf("%d 1\n",i);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5), mod = int(1e9) + 7;
long long a, b;
vector<pair<long long, char> > v;
bool bad(long long a, long long b) {
while (a > 1 && b > 1) {
if (a > b) {
v.push_back(make_pair(a / b, 'A'));
a = a % b;
} else {
v.push_back(make_pair(b / a, 'B'));
b = b % a;
}
}
if (a == 1 || b == 1) {
if (a == 1 && b == 1) return 0;
if (a == 1)
v.push_back(make_pair(b - 1, 'B'));
else
v.push_back(make_pair(a - 1, 'A'));
return 0;
}
return 1;
}
int main() {
cin >> a >> b;
if (bad(a, b)) {
puts("Impossible");
return 0;
}
for (int i = 0; i < v.size(); i++) {
cout << v[i].first << v[i].second;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, i, bolo, ae, j, l;
pair<int, int> a[1000];
vector<int> ans[1000];
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + n + 1);
while (k--) {
for (i = 1; i <= n; i++)
if (a[i].first >= 0) break;
bolo = a[i].first;
for (j = i; j <= n; j++) {
for (l = 1; l <= bolo + 1 && l <= a[j].first; l++)
ans[a[j].second].push_back(k + 1);
}
for (j = i; j <= n; j++)
if (a[j].first > bolo)
a[j].first -= bolo + 1;
else
a[j].first -= bolo;
}
for (i = 1; i <= n; i++)
if (a[i].first > 0) break;
if (i <= n) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (i = 1; i <= n; i++) {
for (j = 0; j < ans[i].size(); j++) cout << ans[i][j] << " ";
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string bin;
while (cin >> n && (n != 0)) {
cin >> bin;
string p, b;
int con = 0;
for (int x = 0; x < bin.size(); x++) {
if (x < bin.size() && con < bin.size()) {
p += '1';
b += '0';
con++;
}
if (x < bin.size() && con < bin.size()) {
p += '0';
b += '1';
con++;
}
}
int conig_p = 0, conig_b = 0;
for (int x = 0; x < bin.size(); x++) {
if (bin[x] == p[x]) conig_p++;
if (bin[x] == b[x]) conig_b++;
}
cout << min(conig_p, conig_b) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> pre;
long long getans(long long l, long long r) {
return (pre[l] + 1) * (pre[r] + 1);
}
int main() {
int n;
long long ans2 = 0;
cin >> n;
string s;
long long ans = 0;
cin >> s;
s += "@";
int len = s.size();
long long tot = 0;
for (int i = 0; i < len; i++) {
if (s[i] == '1' || s[i] == '@') {
pre[i] = tot;
tot = 0;
if (n == 0) ans2 += (pre[i] + 1) * pre[i] / 2;
} else {
tot++;
}
}
if (n == 0) {
cout << ans2;
return 0;
}
int l = 0, r = 0;
while (r < len) {
if (s[r] != '0') {
tot++;
if (tot > n) {
while (s[l] != '1') {
l++;
}
ans += getans(l, r);
l++;
tot--;
}
}
r++;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
char s[100001];
int main() {
gets(s);
int n = strlen(s);
for (int i = 0; i < n; ++i) {
if (s[i] == '"') {
++i;
putchar('<');
while (s[i] != '"') putchar(s[i++]);
puts(">");
} else if (s[i] != ' ') {
putchar('<');
while (i < n && s[i] != ' ' && s[i] != '"') putchar(s[i++]);
puts(">");
--i;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int i = 0;
while (i < n) {
if (s[i] == 'o' && s[i + 1] == 'g' && s[i + 2] == 'o') {
i++;
while (s[i] == 'g' && s[i + 1] == 'o') {
i += 2;
}
cout << "***";
} else {
cout << s[i];
i++;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
void input();
void output();
void solve();
int n;
string str[1000];
int main() {
input();
solve();
output();
}
void input() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) cin >> str[i];
}
void solve() {
vector<vector<bool> > vt;
int size = 0;
for (int i = 0; i < n; ++i) {
vector<bool> temp(26, 0);
for (auto j : str[i]) temp[j - 'a'] = 1;
if (vt.empty()) {
vt.push_back(temp);
++size;
} else {
for (int j = 0; j < size; ++j) {
bool chk = 0;
for (int q = 0; q < 26; ++q) {
if (temp[q] == vt[j][q])
continue;
else {
chk = 1;
break;
}
}
if (!chk)
break;
else {
if (j == size - 1) {
++size;
vt.push_back(temp);
} else
continue;
}
}
}
}
cout << size;
}
void output() {}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int x = 0, y = 0, z = 0;
for (long long int i = 0; i < n; i++) {
long long int a, b, c;
cin >> a >> b >> c;
x = x + a;
y = y + b;
z = z + c;
}
if (x == 0 and y == 0 and z == 0)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
bool a[n][n];
bool b[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
char c;
cin >> c;
if (c == 'X')
a[i][j] = 1;
else
a[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
char c;
cin >> c;
if (c == 'X')
b[i][j] = 1;
else
b[i][j] = 0;
}
}
int x = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == b[i][j])
x++;
else
break;
}
}
if (x == n * n) {
cout << "Yes";
return 0;
}
x = 0;
for (int i = 0, k = 0; i < n && k < n; i++, k++) {
for (int j = 0, l = n - 1; j < n && l >= 0; j++, l--) {
if (a[i][j] == b[l][k])
x++;
else
break;
}
}
if (x == n * n) {
cout << "Yes";
return 0;
}
x = 0;
for (int i = 0, k = n - 1; i < n && k >= 0; i++, k--) {
for (int j = 0, l = n - 1; j < n && l >= 0; j++, l--) {
if (a[i][j] == b[k][l])
x++;
else
break;
}
}
if (x == n * n) {
cout << "Yes";
return 0;
}
x = 0;
for (int i = 0, k = n - 1; i < n && k >= 0; i++, k--) {
for (int j = 0, l = 0; j < n && l < n; j++, l++) {
if (a[i][j] == b[l][k])
x++;
else
break;
}
}
if (x == n * n) {
cout << "Yes";
return 0;
}
x = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == b[j][i])
x++;
else
break;
}
}
if (x == n * n) {
cout << "Yes";
return 0;
}
x = 0;
for (int i = 0, k = 0; i < n && k < n; i++, k++) {
for (int j = 0, l = n - 1; j < n && l >= 0; j++, l--) {
if (a[i][j] == b[k][l])
x++;
else
break;
}
}
if (x == n * n) {
cout << "Yes";
return 0;
}
x = 0;
for (int i = 0, k = n - 1; i < n && k >= 0; i++, k--) {
for (int j = 0, l = n - 1; j < n && l >= 0; j++, l--) {
if (a[i][j] == b[l][k])
x++;
else
break;
}
}
if (x == n * n) {
cout << "Yes";
return 0;
}
x = 0;
for (int i = 0, k = n - 1; i < n && k >= 0; i++, k--) {
for (int j = 0, l = 0; j < n && l < n; j++, l++) {
if (a[i][j] == b[k][l])
x++;
else
break;
}
}
if (x == n * n) {
cout << "Yes";
return 0;
}
cout << "No";
return 0;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int a, b, k, t, dp[5][700005], s[5][700005];
int q(int x, int l, int r) {
return (s[x][r] - s[x][l - 1] + 1000000007) % 1000000007;
}
int main() {
scanf("%d%d%d%d", &a, &b, &k, &t);
dp[0][350000 + a - b] = 1;
for (int i = 1; i <= 350000 * 2; i++) s[0][i] = s[0][i - 1] + dp[0][i];
for (int i = 1; i <= 2 * t; i++) {
for (int j = 1; j <= 350000 * 2; j++)
dp[i & 1][j] =
q((i - 1) & 1, std::max(1, j - k), std::min(350000 * 2, j + k));
for (int j = 1; j <= 350000 * 2; j++)
s[i & 1][j] = (s[i & 1][j - 1] + dp[i & 1][j]) % 1000000007;
}
printf("%d\n", q((2 * t) & 1, 350000 + 1, 350000 * 2));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int b[1000006];
int main() {
int n = 0, k, g;
cin >> k;
for (int i = 0; i < k; i++) {
scanf("%d", &g);
if (!b[g]++) a[n++] = g;
}
sort(a, a + n);
int mx = 0;
for (int i = 0; i < n; i++) {
for (int j = 2; j * a[i] <= 2 * a[n - 1]; j++) {
int f = (lower_bound(a + i, a + n, j * a[i]) - a) - 1;
if (f < 0) f++;
mx = max(mx, a[f] % a[i]);
}
}
cout << mx << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int bestTeam;
void optimize() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int nSetBits(int n) {
unsigned int count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
int main() {
optimize();
map<string, int> nameToInt;
string name, names[17];
int i, j, n, m, forbidden[289] = {0};
cin >> n >> m;
for (i = 0; i < n; names[i] = name, ++i) cin >> name;
sort(names, names + n);
for (i = 0; i < n; ++i) nameToInt[names[i]] = i;
for (i = 0; i < m; ++i) {
cin >> name;
forbidden[i] |= 1 << nameToInt[name];
cin >> name;
forbidden[i] |= 1 << nameToInt[name];
}
for (int i = (1 << n) - 1; i > 0; --i) {
for (j = 0; j < m; ++j)
if ((forbidden[j] & i) == forbidden[j]) break;
if (j == m && nSetBits(bestTeam) < nSetBits(i)) bestTeam = i;
}
cout << nSetBits(bestTeam) << "\n";
for (i = 0; i < n; ++i)
if (bestTeam & (1 << i)) cout << names[i] << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
if (n & 1)
cout << "Ehab" << endl;
else
cout << "Mahmoud" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
int a[1005];
vector<int> ans;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
ans.push_back(a[1]);
for (int i = 2; i <= n; i++) {
if (gcd(a[i], a[i - 1]) == 1) {
ans.push_back(a[i]);
continue;
}
ans.push_back(1);
ans.push_back(a[i]);
}
printf("%d\n", ans.size() - n);
for (int i = 0; i < ans.size() - 1; i++) printf("%d ", ans[i]);
printf("%d\n", ans[ans.size() - 1]);
return 0;
}
| 2 |
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
// #include <atcoder/all>
// #include <bits/stdc++.h>
#include <complex>
#include <queue>
#include <set>
#include <unordered_set>
#include <list>
#include <chrono>
#include <random>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <stack>
#include <iomanip>
#include <fstream>
using namespace std;
// using namespace atcoder;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> p32;
typedef pair<ll, ll> p64;
typedef pair<p64, p64> pp64;
typedef pair<double, double> pdd;
typedef vector<ll> v64;
typedef vector<int> v32;
typedef vector<vector<int>> vv32;
typedef vector<vector<ll>> vv64;
typedef vector<vector<p64>> vvp64;
typedef vector<p64> vp64;
typedef vector<p32> vp32;
ll MOD = 1e9 + 7;
double eps = 1e-12;
#define forn(i, e) for (ll i = 0; i < e; i++)
#define forsn(i, s, e) for (ll i = s; i < e; i++)
#define rforn(i, s) for (ll i = s; i >= 0; i--)
#define rforsn(i, s, e) for (ll i = s; i >= e; i--)
#define ln '\n'
#define dbg(x) cout << #x << " = " << x << ln
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define INF 2e18
#define fast_cin() \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((ll)(x).size())
#define zero ll(0)
#define set_bits(x) __builtin_popcountll(x)
// #define mint modint998244353
int LIM = 2e5 + 100;
v64 arr(LIM);
v64 rev(LIM);
vp64 ans;
v64 counter(LIM);
void c_swap(int a, int b)
{
ans.push_back({a, b});
counter[arr[a]] = 1 - counter[arr[a]];
counter[arr[b]] = 1 - counter[arr[b]];
swap(arr[a], arr[b]);
rev[arr[a]] = a;
rev[arr[b]] = b;
}
int reduce(int a)
{
bool f = 0;
int cur = a;
while (true)
{
int start = cur;
while (counter[cur] - counter[arr[cur]] != 1)
{
cur = arr[cur];
if (cur == start)
return cur;
}
int next = arr[cur];
c_swap(cur, rev[cur]);
cur = next;
}
return -1;
}
void solve()
{
int n;
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> arr[i];
rev[arr[i]] = i;
}
vp64 roots;
v64 visited(n + 1, 0);
for (int i = 1; i <= n; i++)
{
if (visited[i] == 0)
{
int cur = arr[i];
visited[cur] = 1;
int num = 1;
while (cur != i)
{
cur = arr[cur];
visited[cur] = 1;
num++;
}
roots.push_back({num, i});
}
}
sort(all(roots));
if (sz(roots) > 1)
{
int m = sz(roots);
for (int i = 0; i + 1 < sz(roots); i += 2)
{
if (sz(roots) & 1)
{
if (i == sz(roots) - 3)
break;
}
c_swap(roots[i].se, roots[i + 1].se);
int cur = reduce(roots[i].se);
c_swap(cur, arr[cur]);
}
if (sz(roots) & 1)
{
int a = roots[m - 1].se, b = roots[m - 2].se, c = roots[m - 3].se;
if (roots[m - 1].fi + roots[m - 2].fi + roots[m - 3].fi != 3)
{
c_swap(a, b);
for (int i = a;; i = arr[i])
{
if (counter[arr[i]] == 0)
{
c_swap(i, c);
break;
}
}
int cur = reduce(c);
c_swap(cur, arr[cur]);
cur = reduce(c);
c_swap(cur, arr[cur]);
}
}
}
else
{
int a = arr[roots[0].se];
c_swap(roots[0].se, arr[roots[0].se]);
for (int i = roots[0].se;; i = arr[i])
{
if (counter[i])
{
c_swap(i, a);
break;
}
}
int cur = reduce(a);
c_swap(cur, arr[cur]);
}
cout << sz(ans) << endl;
for (int i = 0; i < sz(ans); i++)
{
cout << ans[i].fi << " " << ans[i].se << endl;
}
}
int main()
{
fast_cin();
ll t = 1;
// cin >> t;
forn(i, t)
{
// cout << "Case #" << i+1 << ": ";
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
int n;
int ans = 0;
cin >> n;
if (n == 0) ans++;
while (n > 0) {
int x = n % 16;
n /= 16;
if (x == 0 || x == 4 || x == 6 || x == 9 || x == 10 || x == 13)
ans++;
else if (x == 8 || x == 11)
ans += 2;
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 60;
int n, m;
bool res = true;
char c[maxN][maxN];
bool check(int x1, int y1, int x2, int y2, int x3, int y3) {
int x = x1, y = y1;
while (x != x2 || y != y2) {
if (c[x][y] == 'W') return false;
if (x2 != x) {
if (x2 < x)
--x;
else
++x;
} else {
if (y2 < y)
--y;
else
++y;
}
}
while (x != x3 || y != y3) {
if (c[x][y] == 'W') return false;
if (x3 != x) {
if (x3 < x)
--x;
else
++x;
} else {
if (y3 < y)
--y;
else
++y;
}
}
return true;
}
int main() {
cin >> n >> m;
for (int i = (int)0; i <= (int)n - 1; ++i)
for (int j = (int)0; j <= (int)m - 1; ++j) cin >> c[i][j];
for (int x1 = (int)0; x1 <= (int)n - 1; ++x1)
for (int y1 = (int)0; y1 <= (int)m - 1; ++y1) {
if (c[x1][y1] == 'W') continue;
for (int x2 = (int)0; x2 <= (int)n - 1; ++x2)
for (int y2 = (int)0; y2 <= (int)m - 1; ++y2) {
if (x1 == x2 && y1 == y2) continue;
if (c[x2][y2] == 'W') continue;
bool ok = false;
if (check(x1, y1, x1, y2, x2, y2)) ok = true;
if (check(x1, y1, x2, y1, x2, y2)) ok = true;
if (!ok) res = false;
}
}
printf(res ? "YES" : "NO");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (1LL << 60);
int N, M;
long long B;
struct student {
long long cost;
int mask;
int monitors;
};
bool cmp(student s, student t) { return s.monitors < t.monitors; }
student S[105];
long long dp[1 << 20];
int main() {
scanf("%d%d%I64d", &N, &M, &B);
for (int i = 0; i < N; i++) {
int K;
scanf("%I64d%d%d", &S[i].cost, &S[i].monitors, &K);
S[i].mask = 0;
for (int k = 0; k < K; k++) {
int x;
scanf("%d", &x);
S[i].mask |= (1 << (--x));
}
}
sort(S, S + N, cmp);
for (int i = 0; i < (1 << M); i++) dp[i] = INF;
dp[0] = 0;
long long monitors = 0;
long long best = INF;
for (int s = 0; s < N; s++) {
for (int i = 0; i < (1 << M); i++)
dp[i | S[s].mask] = min(dp[i | S[s].mask], dp[i] + S[s].cost);
best = min(best, dp[(1 << M) - 1] + S[s].monitors * B);
}
printf("%I64d\n", best == INF ? -1 : best);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 2e5 + 10, wax = 20, inf = 4e18, mod = 1e9 + 7;
const long double pi = 3.14159265359, eps = 1e-9;
long long n;
vector<long long> g[maxn];
long long wis[2][maxn / 2];
long long dis[maxn];
deque<long long> q;
void bfs(long long source) {
q.push_back(source);
dis[source] = 0;
long long v;
while (((long long)q.size())) {
v = q.back();
q.pop_back();
for (long long u : g[v]) {
if (dis[u] > dis[v] + 1) {
dis[u] = dis[v] + 1;
q.push_front(u);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
long long v, u;
for (int i = 0; i < n; i++) {
g[2 * i].push_back(2 * i + 1), g[2 * i + 1].push_back(2 * i);
cin >> v >> u;
v--, u--;
g[v].push_back(u), g[u].push_back(v);
wis[0][i] = v, wis[1][i] = u;
}
memset(dis, 69, sizeof(dis));
for (int i = 0; i < 2 * n; i++)
if (dis[i] >= inf) bfs(i);
for (int i = 0; i < n; i++)
cout << dis[wis[0][i]] % 2 + 1 << ' ' << dis[wis[1][i]] % 2 + 1 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int ans[185];
vector<int> q[185];
int main() {
for (int i = 1; i < 180; i++) {
ans[i] = -1;
}
for (int i = 3; i <= 180; i++) {
for (int j = 1; j <= i - 2; j++) {
if ((180 * j) % i == 0) {
q[i].push_back((j * 180) / i);
}
}
}
for (int i = 3; i <= 180; i++) {
for (int j = 0; j < q[i].size(); j++) {
if (ans[q[i][j]] == -1) {
ans[q[i][j]] = i;
}
}
}
ans[179] = 360;
int t, n;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
printf("%d\n", ans[n]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void find_primes(set<int> &s) {
for (int i = 51; i <= 1000; i += 2) {
bool flag = 0;
for (auto it = s.begin(); (*it) * (*it) <= i; it++) {
if (i % (*it) == 0) {
flag = 1;
break;
}
}
if (!flag) s.insert(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
set<int> primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47};
find_primes(primes);
int n;
cin >> n;
int ans = 0;
vector<int> answer;
answer.reserve(1000);
for (auto it = primes.begin(); it != primes.end(); it++) {
int prime = (*it);
int k = prime;
while (prime <= n) {
ans++;
answer.emplace_back(prime);
prime *= k;
}
}
cout << ans << '\n';
for (int i : answer) cout << i << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long par[1005];
long long deg[1005];
long long cnt[1005];
int main() {
long long n;
cin >> n;
for (long long i = 2; i <= n; i++) {
long long a;
cin >> a;
par[i] = a;
deg[a]++;
}
for (long long i = 1; i <= n; i++) {
if (!deg[i]) cnt[par[i]]++;
}
for (long long i = 1; i <= n; i++) {
if (deg[i] > 0 && cnt[i] < 3) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9, MAX = 200001, MOD = 1000000007;
int n, m;
set<int, greater<int>> adj[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (*adj[i].begin() > i) cnt++;
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a, u, v;
cin >> a;
if (a == 1) {
cin >> u >> v;
if (*adj[u].begin() > u) cnt--;
adj[u].insert(v);
if (*adj[u].begin() > u) cnt++;
if (*adj[v].begin() > v) cnt--;
adj[v].insert(u);
if (*adj[v].begin() > v) cnt++;
} else if (a == 2) {
cin >> u >> v;
if (*adj[u].begin() > u) cnt--;
adj[u].erase(v);
if (*adj[u].begin() > u) cnt++;
if (*adj[v].begin() > v) cnt--;
adj[v].erase(u);
if (*adj[v].begin() > v) cnt++;
} else {
cout << n - cnt << '\n';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
vector<int> pl, pr;
int tree[N], n;
void update(int k, int v) {
while (k < N) {
tree[k] += v;
k += k & (-k);
}
}
int get(int k) {
int ret = 0;
while (k) {
ret += tree[k];
k -= k & (-k);
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x == 0)
pl.push_back(i);
else
pr.push_back(i);
}
long long ans = 0;
memset(tree, 0, sizeof(tree));
for (int i = 0; i < pr.size(); i++) update(pr[i], 1);
for (int i = 0; i < pl.size(); i++) {
ans += get(pl[i]);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int OO = 2e7;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
bool sort_p(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
const double PI = acos(-1.0);
long long int mod = 2000000011;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
int main() {
int n;
cin >> n;
vector<long long int> a(n);
long long int mx = 0;
for (int i = 0; i < (int)(n); ++i) {
cin >> a[i];
if (a[i] > mx) mx = a[i];
}
int l = 0;
int m = 0;
for (int i = 0; i < (int)(n); ++i) {
if (i == n - 1) {
if (a[i] == mx)
m = max(m, l + 1);
else
m = max(m, l);
break;
}
if (a[i] == mx)
l++;
else {
m = max(m, l);
l = 0;
}
}
cout << m;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, cur = 0, ans = 0;
cin >> n;
for (int i = n; i > 1; i--) {
for (int j = 0; j < i; j++) {
ans += 1 + cur;
if (!j) ans -= cur;
}
++cur;
}
ans += 1;
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 1e5 + 7;
vector<long long> adj[mxn];
long long ans;
long long cat[mxn];
long long m, n;
void dfs(long long s, long long cur, long long par) {
if (cat[s])
cur++;
else
cur = 0;
if (cur > m) return;
if (adj[s].size() == 1 && s != 0) ans++;
for (long long node : adj[s]) {
if (node == par) continue;
dfs(node, cur, s);
}
}
int main() {
ans = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> cat[i];
for (int i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(0, 0, -1);
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long sum = ((long long)n * (n + 1)) / 2;
if (sum % 2 == 0) {
cout << 0 << endl;
} else {
cout << 1 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e12;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
vector<pair<long long, int>> a;
for (int i = 0, j = 0; i < n; i = j) {
for (; j < n && s[i] == s[j]; j++)
;
a.push_back({(long long)(j - i), s[i] - '0'});
}
vector<long long> cost(n + 1);
for (int i = 1; i <= n; i++) {
cin >> cost[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j < i; j++) {
cost[i] = max(cost[i], cost[j] + cost[i - j]);
}
}
int m = a.size();
vector<vector<vector<vector<long long>>>> dp(
m, vector<vector<vector<long long>>>(
m, vector<vector<long long>>(2, vector<long long>(n + 1, -1))));
for (int i = 0; i < m; i++) {
dp[i][i][a[i].second][a[i].first] = 0;
for (int j = 1; j <= a[i].first; j++) {
dp[i][i][a[i].second][a[i].first - j] = cost[j];
}
dp[i][i][a[i].second ^ 1][0] = dp[i][i][a[i].second][0];
}
for (int i = 2; i <= m; i++) {
for (int l = 0; l + i - 1 < m; l++) {
int r = l + i - 1;
for (int val = 0; val <= n; val++) {
if (val + a[l].first <= n && dp[l + 1][r][a[l].second][val] != -1)
dp[l][r][a[l].second][val + a[l].first] =
dp[l + 1][r][a[l].second][val];
}
for (int mid = l; mid + 1 <= r; mid++) {
for (int val = 0; val <= n; val++) {
if (dp[mid + 1][r][a[l].second ^ 1][val] != -1)
dp[l][r][a[l].second ^ 1][val] =
max(dp[l][r][a[l].second ^ 1][val],
dp[mid + 1][r][a[l].second ^ 1][val] + dp[l][mid][0][0]);
}
}
for (int bt = 0; bt < 2; bt++) {
for (int val = 0; val <= n; val++) {
for (int cc = 1; cc <= n; cc++) {
if (dp[l][r][bt][val] != -1 && val - cc >= 0) {
dp[l][r][bt][val - cc] =
max(dp[l][r][bt][val - cc], cost[cc] + dp[l][r][bt][val]);
}
}
}
}
dp[l][r][0][0] = dp[l][r][1][0] = max(dp[l][r][0][0], dp[l][r][1][0]);
}
}
cout << dp[0][m - 1][0][0] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int P = 1000000007;
inline int mul(const int &a, const int &b) { return 1ll * a * b % P; }
inline int sub(int a, const int &b) {
a -= b;
return (a < 0) ? a + P : a;
}
inline int add(int a, const int &b) {
a += b;
return (a >= P) ? a - P : a;
}
int qsm(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = mul(ans, a);
a = mul(a, a);
b >>= 1;
}
return ans;
}
int n, k, f[5001];
int main() {
scanf("%d%d", &n, &k);
int ans = 1;
f[0] = 1;
for (int i = 1, tem; i <= n; i++) {
scanf("%d", &tem);
ans = mul(ans, tem);
for (int j = n; ~j; --j) {
f[j] = mul(f[j], tem);
if (j) f[j] = sub(f[j], f[j - 1]);
}
}
int inv = qsm(n, P - 2);
for (int i = 0, Mul = 1; i <= n; i++) {
ans = sub(ans, mul(f[i], Mul));
Mul = mul(Mul, k - i);
Mul = mul(Mul, inv);
}
printf("%d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int out(pair<int, int> k, int n, int m) {
if (k.first < 0 || k.first > n || k.second < 0 || k.second > m) return 1;
return 0;
}
double dist(pair<int, int> a, pair<int, int> b) {
return sqrt(((a.first - b.first) * (a.first - b.first)) +
((a.second - b.second) * (a.second - b.second)));
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n == 0)
printf("0 1\n0 %d\n0 0\n0 %d\n", m, m - 1);
else if (m == 0)
printf("1 0\n%d 0\n0 0\n%d 0\n", n, n - 1);
else {
vector<pair<int, int> > v1;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) v1.push_back(pair<int, int>(i, j));
vector<pair<int, int> > v2;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++) v2.push_back(pair<int, int>(n - i, m - j));
vector<pair<int, int> > ans;
double best = 0;
for (int i = 0; i < 64; i++)
for (int j = 0; j < 64; j++)
for (int k = 0; k < 64; k++)
for (int l = 0; l < 64; l++) {
if (i == j || k == l) continue;
if (v1[i] == v2[k] || v1[i] == v2[l]) continue;
if (v1[j] == v2[k] || v1[j] == v2[l]) continue;
if (out(v1[i], n, m)) continue;
if (out(v1[j], n, m)) continue;
if (out(v2[k], n, m)) continue;
if (out(v2[l], n, m)) continue;
double dd =
dist(v1[i], v2[k]) + dist(v2[k], v1[j]) + dist(v1[j], v2[l]);
if (dd > best) {
best = dd;
ans.clear();
ans.push_back(v1[i]);
ans.push_back(v2[k]);
ans.push_back(v1[j]);
ans.push_back(v2[l]);
}
}
for (int i = 0; i < 4; i++) printf("%d %d\n", ans[i].first, ans[i].second);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 100;
const int maxm = 200000 + 100;
const int maxt = 3000000 + 100;
const int maxk = 10 + 3;
const long long unit = 1LL;
const int INF = 0x3f3f3f3f;
const long long Inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-3;
const double inf = 1e15;
const double pi = acos(-1.0);
const long long mod = 1000000007LL;
inline long long read() {
long long x = 0;
bool t = false;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = true, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return t ? -x : x;
}
struct EasyMath {
inline long long Quick_Pow(long long a, long long b) {
long long sum = 1;
for (; b; b >>= 1, a = (long long)a * a % mod)
if (b & 1) sum = sum * a % mod;
return sum;
}
inline long long inv(long long x) { return Quick_Pow(x, mod - 2); }
} em;
struct Graph {
struct Edge {
int to, next;
};
Edge edge[maxm];
int tot, head[maxn];
void init() {
tot = 1;
memset(head, 0, sizeof(head));
}
void AddEdge(int u, int v) {
edge[tot] = (Edge){v, head[u]};
head[u] = tot++;
}
} G;
struct HLD {
int n, m, dfs_clock;
int dfn[maxn], top[maxn], son[maxn], Size[maxn], fa[maxn], dep[maxn];
void init(Graph &G) {
dfs1(G, 1, 0);
dfs2(G, 1, 1);
}
void dfs1(Graph &G, int u, int ff) {
fa[u] = ff;
son[u] = 0;
Size[u] = 1;
dep[u] = dep[ff] + 1;
for (int i = G.head[u]; i; i = G.edge[i].next) {
int v = G.edge[i].to;
if (v == ff) continue;
dfs1(G, v, u);
Size[u] += Size[v];
if (Size[v] > Size[son[u]]) son[u] = v;
}
}
void dfs2(Graph &G, int u, int tp) {
dfn[u] = ++dfs_clock;
top[u] = tp;
if (!son[u]) return;
dfs2(G, son[u], tp);
for (int i = G.head[u]; i; i = G.edge[i].next) {
int v = G.edge[i].to;
if (v == fa[u] || v == son[u]) continue;
dfs2(G, v, v);
}
}
int lca(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
x = fa[top[x]];
}
return dep[x] < dep[y] ? x : y;
}
} hld;
long long n, g[maxn], dep[maxn], sum[maxn << 2], lazy[maxn << 2];
vector<int> in[maxn], out[maxn];
void Build(int l, int r, int rt) {
if (l == r) {
sum[rt] = 0;
return;
}
int m = (l + r) >> 1;
Build(l, m, rt << 1), Build(m + 1, r, rt << 1 | 1);
}
void PushDown(int l, int r, int rt) {
if (lazy[rt]) {
int m = (l + r) >> 1;
(sum[rt << 1] += (m - l + 1) * lazy[rt] % mod) %= mod;
(sum[rt << 1 | 1] += (r - m) * lazy[rt] % mod) %= mod;
(lazy[rt << 1] += lazy[rt]) %= mod;
(lazy[rt << 1 | 1] += lazy[rt]) %= mod;
lazy[rt] = 0;
}
}
void PushUp(int rt) { sum[rt] = (sum[rt << 1] + sum[rt << 1 | 1]) % mod; }
void Add(int L, int R, long long x, int l, int r, int rt) {
if (L <= l && r <= R) {
(sum[rt] += (r - l + 1) * x % mod) %= mod;
(lazy[rt] += x) %= mod;
return;
}
PushDown(l, r, rt);
int m = (l + r) >> 1;
if (L <= m) Add(L, R, x, l, m, rt << 1);
if (R > m) Add(L, R, x, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
long long AskSum(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return sum[rt];
PushDown(l, r, rt);
int m = (l + r) >> 1;
long long ans = 0;
if (L <= m) (ans += AskSum(L, R, l, m, rt << 1)) %= mod;
if (R > m) (ans += AskSum(L, R, m + 1, r, rt << 1 | 1)) %= mod;
PushUp(rt);
return ans;
}
void add(int u, long long x) {
while (u) {
Add(hld.dfn[hld.top[u]], hld.dfn[u], x, 1, n, 1);
u = hld.fa[hld.top[u]];
}
}
long long calc(int u) {
long long ans = mod - AskSum(1, 1, 1, n, 1);
while (u) {
(ans += AskSum(hld.dfn[hld.top[u]], hld.dfn[u], 1, n, 1)) %= mod;
u = hld.fa[hld.top[u]];
}
return ans;
}
int main() {
n = read();
Build(1, n, 1);
int l, r, cm = 0;
long long p = 1;
for (int i = 1; i <= n; ++i) {
l = read(), r = read();
(p *= (r - l + 1)) %= mod;
g[i] = em.inv(r - l + 1);
cm = max(cm, r);
in[l].push_back(i);
out[r + 1].push_back(i);
}
int u, v;
G.init();
for (int i = 0; i < n - 1; ++i) {
u = read(), v = read();
G.AddEdge(u, v);
G.AddEdge(v, u);
}
hld.init(G);
for (int i = 1; i <= n; ++i) dep[i] = hld.dep[i] - 1;
long long a = 0, b = 0, c = 0, d = 0, ans = 0;
for (int i = 1; i <= cm; ++i) {
for (auto x : out[i]) {
(a -= dep[x] * g[x] % mod) %= mod;
(a += mod) %= mod;
(b -= g[x]) %= mod;
(b += mod) %= mod;
(c -= dep[x] * g[x] % mod * g[x] % mod) %= mod;
(c += mod) %= mod;
add(x, mod - g[x]);
(d -= g[x] * calc(x) % mod) %= mod;
(d += mod) %= mod;
}
for (auto x : in[i]) {
(a += dep[x] * g[x] % mod) %= mod;
(b += g[x]) %= mod;
(c += dep[x] * g[x] % mod * g[x] % mod) %= mod;
(d += g[x] * calc(x)) %= mod;
add(x, g[x]);
}
(ans += a * b % mod) %= mod;
(ans -= c) %= mod;
(ans -= 2 * d % mod) %= mod;
(ans += mod) %= mod;
}
printf("%lld\n", (p * ans) % mod);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int rd() { return RAND_MAX == 32767 ? ((rand() << 15) ^ rand()) : rand(); }
const int maxn = 100010;
int a[maxn];
struct Segment {
int l, r, sum;
Segment() {}
Segment(int l_, int r_, int sum_) : l(l_), r(r_), sum(sum_) {}
Segment operator+(const Segment &o) const {
Segment res;
res.sum = sum + o.sum;
res.l = l;
res.r = o.r;
return res;
}
bool operator<(const Segment &o) const { return sum < o.sum; }
} cntR, cntS;
struct Tree {
int l, r, chg;
Segment sum, maxL, maxR, maxS, minL, minR, minS;
Tree *lc, *rc;
void setNode(int val) {
sum = Segment(l, r, val);
if (val > 0)
maxL = maxR = maxS = Segment(l, r, val);
else {
maxL = maxS = Segment(l, l, 0);
maxR = Segment(r, r, 0);
}
if (val < 0)
minL = minR = minS = Segment(l, r, val);
else {
minL = minS = Segment(l, l, 0);
minR = Segment(r, r, 0);
}
}
Tree(int l_, int r_) : l(l_), r(r_) {
lc = l + 1 < r ? new Tree(l, (l + r) >> 1) : NULL;
rc = l + 1 < r ? new Tree((l + r) >> 1, r) : NULL;
chg = 0;
if (l + 1 < r)
fresh();
else
setNode(a[l]);
}
void fresh() {
maxS = max(max(lc->maxS, rc->maxS), lc->maxR + rc->maxL);
maxL = max(lc->maxL, lc->sum + rc->maxL);
maxR = max(rc->maxR, lc->maxR + rc->sum);
minS = min(min(lc->minS, rc->minS), lc->minR + rc->minL);
minL = min(lc->minL, lc->sum + rc->minL);
minR = min(rc->minR, lc->minR + rc->sum);
sum = lc->sum + rc->sum;
}
void modify() {
chg ^= 1;
swap(minL, maxL);
swap(minR, maxR);
swap(minS, maxS);
maxL.sum = -maxL.sum;
maxR.sum = -maxR.sum;
maxS.sum = -maxS.sum;
minL.sum = -minL.sum;
minR.sum = -minR.sum;
minS.sum = -minS.sum;
sum.sum = -sum.sum;
}
void down() {
chg = 0;
lc->modify();
rc->modify();
}
void change(int x, int y) {
if (l + 1 == r)
setNode(y);
else {
if (chg) down();
x < (l + r) >> 1 ? lc->change(x, y) : rc->change(x, y);
fresh();
}
}
void query(int ll, int rr) {
if (ll <= l && rr >= r) {
cntS = max(max(cntS, maxS), cntR + maxL);
cntR = max(maxR, cntR + sum);
} else {
if (chg) down();
if (ll < (l + r) >> 1) lc->query(ll, rr);
if (rr > (l + r) >> 1) rc->query(ll, rr);
fresh();
}
}
void negative(int ll, int rr) {
if (ll <= l && rr >= r)
modify();
else {
if (chg) down();
if (ll < (l + r) >> 1) lc->negative(ll, rr);
if (rr > (l + r) >> 1) rc->negative(ll, rr);
fresh();
}
}
} * root;
int main() {
int n, m;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
root = new Tree(0, n);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int opt;
scanf("%d", &opt);
if (opt == 0) {
int pos, val;
scanf("%d%d", &pos, &val);
pos--;
root->change(pos, val);
} else {
int l, r, k, res = 0;
scanf("%d%d%d", &l, &r, &k);
l--;
vector<pair<int, int> > b;
for (int i = 0; i < k; i++) {
cntS = cntR = Segment(l, l, 0);
root->query(l, r);
res += cntS.sum;
if (cntS.l < cntS.r) {
root->negative(cntS.l, cntS.r);
b.push_back(make_pair(cntS.l, cntS.r));
} else
break;
}
for (int i = 0; i < b.size(); i++)
root->negative(b[i].first, b[i].second);
printf("%d\n", res);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
string s[100];
long long dp[100][2][2][2];
long long ans(long long pos, long long lc, long long dig, long long sym) {
if (dp[pos][lc][dig][sym] != -1) return dp[pos][lc][dig][sym];
if (pos == n + 1) {
if (lc && dig && sym)
return 0;
else
return 100000000000000LL;
}
long long y = 100000000000000LL;
for (long long i = 0; i < m; ++i) {
if (isdigit(s[pos][i])) {
y = min(y, i + ans(pos + 1, lc, 1, sym));
} else if (s[pos][i] == '#' || s[pos][i] == '*' || s[pos][i] == '&') {
y = min(y, i + ans(pos + 1, lc, dig, 1));
} else {
y = min(y, i + ans(pos + 1, 1, dig, sym));
}
}
for (long long i = 1; i <= m; ++i) {
if (isdigit(s[pos][m - i])) {
y = min(y, i + ans(pos + 1, lc, 1, sym));
} else if (s[pos][m - i] == '#' || s[pos][m - i] == '*' ||
s[pos][m - i] == '&') {
y = min(y, i + ans(pos + 1, lc, dig, 1));
} else {
y = min(y, i + ans(pos + 1, 1, dig, sym));
}
}
return dp[pos][lc][dig][sym] = y;
}
signed main() {
scanf("%lld", &n);
scanf("%lld", &m);
memset(dp, -1, sizeof(dp));
for (long long i = 1; i <= n; ++i) {
cin >> s[i];
}
cout << ans(1, 0, 0, 0);
return 0;
}
| 3 |
// A.cpp
// Created by David del Val on 03/07/2021
//
//
//https://github.com/Ddelval/Competitive-programming/blob/master/template.cpp
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
template <typename T, typename Q>
inline ostream &operator<<(ostream &o, pair<T, Q> p);
// ====================================================== //
// =================== Container IO =================== //
// ====================================================== //
template <bool B, typename T = void>
using Enable_if = typename std::enable_if<B, T>::type;
struct subs_fail {};
template <typename T>
struct subs_succeeded : std::true_type {};
template <>
struct subs_succeeded<subs_fail> : std::false_type {};
template <typename T>
struct get_iter_res {
private:
template <typename X>
static auto check(X const &x) -> decltype(x.begin());
static subs_fail check(...);
public:
using type = decltype(check(std::declval<T>()));
};
template <typename T>
struct Has_iterator : subs_succeeded<typename get_iter_res<T>::type> {};
template <>
struct Has_iterator<string> : subs_fail {};
constexpr const char *sep1 = " ";
constexpr const char *sep2 = "\n";
template <typename T>
struct get_termination {
static constexpr const char *get() {
return sep1;
}
};
template <typename U, typename S>
struct get_termination<vector<U, S>> {
static constexpr const char *get() {
return sep2;
}
};
template <typename T>
Enable_if<Has_iterator<T>::value, ostream &> operator<<(ostream &o, T val) {
bool first = true;
for (auto it = val.begin(); it != val.end(); ++it) {
if (!first) {
constexpr const char *terminator = get_termination<typename T::value_type>::get();
o << terminator;
}
first = false;
o << *it;
}
return o;
}
template <typename T = ll>
inline vector<T> readVector(int size) {
vector<T> v;
v.reserve(size);
T a;
for (int i = 0; i < size; ++i) {
cin >> a;
v.push_back(a);
}
return v;
}
// ====================================================== //
// ================== Pairs operations ================== //
// ====================================================== //
inline pii operator+(pii a, pii b) {
return {a.fi + b.fi, a.se + b.se};
}
template <typename T, typename Q>
inline ostream &operator<<(ostream &o, pair<T, Q> p) {
o << "(" << p.fi << "," << p.se << ")";
return o;
}
//gcd(0, n) = n
inline long long _gcd(long long a, long long b) {
while (b)
b %= a ^= b ^= a ^= b;
return a;
}
ll inf = LLONG_MAX / 10;
int iinf = INT_MAX / 10;
#ifdef _LOCAL_
//Local constraints
#else
// Judge constraints
#endif
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vi pos;
pos.reserve(n);
for (int i = 0; i < n; ++i) {
pos.push_back(i + 1);
}
for (int i = 0; i < 2 * (n / 2); i += 2) {
swap(pos[i], pos[i + 1]);
}
if (n % 2) {
swap(pos[n - 2], pos[n - 1]);
}
cout << pos << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
double a[maxn], ans, x, y;
int n, k;
double dis(int i) { return sqrt(y * y + (x - a[i]) * (x - a[i])); }
double back(int l, int r) { return a[r] - a[l] + min(dis(l), dis(r)); }
double gone(int l, int r) {
return a[r] - a[l] +
min(fabs(a[k] - a[l]) + dis(r), fabs(a[r] - a[k]) + dis(l));
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%lf", &a[i]);
int ram = a[k];
scanf("%lf%lf", &x, &y);
sort(a + 1, a + 1 + n);
if (k == n + 1)
ans = back(1, n);
else {
for (int i = 1; i <= n; i++)
if (ram == a[i]) k = i;
ans = gone(1, n);
for (int i = 1; i <= n; i++) {
if (i != 1) ans = min(ans, gone(1, i - 1) + back(i, n));
if (i != n) ans = min(ans, gone(i + 1, n) + back(1, i));
}
}
printf("%.12lf\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int i = 0, f = 1;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
i = (i << 1) + (i << 3) + ch - '0';
ch = getchar();
}
return i * f;
}
const int Maxn = 1e6 + 50;
int a_array[Maxn], b_array[Maxn], *a = a_array, *b = b_array;
int n, posa[Maxn], posb[Maxn];
long long suma, sumb;
int main() {
n = read();
for (int i = 1; i <= n; i++) {
suma += (a[i] = read());
}
for (int i = 1; i <= n; i++) {
sumb += (b[i] = read());
}
if (sumb < suma) swap(a, b);
posa[0] = 1;
posb[0] = 1;
int head1 = 1, head2 = 0, delta = a[1], bz = 0, pos1, pos2, pos3, pos4;
while (head1 <= n && (!bz)) {
while (delta > 0) delta -= b[++head2];
if (posa[(-delta)]) {
pos1 = posa[(-delta)];
pos2 = head1;
pos3 = posb[(-delta)];
pos4 = head2;
bz = 1;
} else {
posa[(-delta)] = head1 + 1;
posb[(-delta)] = head2 + 1;
}
++head1;
delta += a[head1];
}
if (a != a_array) {
swap(pos1, pos3);
swap(pos2, pos4);
swap(a, b);
}
static int p[Maxn];
cout << pos2 - pos1 + 1 << endl;
for (int i = pos1; i <= pos2; i++) cout << i << " ";
cout << endl;
swap(pos1, pos3);
swap(pos2, pos4);
swap(a, b);
cout << pos2 - pos1 + 1 << endl;
for (int i = pos1; i <= pos2; i++) cout << i << " ";
cout << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
double pi = 2 * acos(0.0);
vector<int> ans, p;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
for (const auto &x : v) os << " " << x;
return os << '}';
}
int ss(int n, int i) {
string s;
int x = n;
while (x) {
int mod = x % 2;
s += mod + '0';
x /= 2;
}
int sz = s.size();
while (sz < 8) {
s += '0';
sz++;
}
int num = 0, k = 1;
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] == '1') {
num += k;
}
k *= 2;
}
p.push_back(num);
if (i > 0) {
num = p[i - 1] - num;
} else {
num = 0 - num;
}
if (num < 0) num += 256;
num %= 256;
return num;
}
void solve() {
char ch;
string s;
while (true) {
ch = getchar();
if (ch == '\n') break;
s += ch;
}
int n = s.size();
for (int i = 0; i < n; i++) {
int x = int(s[i]);
int aa = ss(x, i);
ans.push_back(aa);
}
for (auto it = ans.begin(); it != ans.end(); it++) {
cout << *it << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int test_cases = 1;
for (int tc = 1; tc <= test_cases; tc++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
char Puz[105][105], ch;
bool flag[105][105], ok;
int i, j, k, n, m;
int main() {
scanf("%d%d", &n, &m);
scanf("%c", &ch);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%c", &ch);
Puz[i][j] = ch;
}
scanf("%c", &ch);
}
memset(flag, 0, sizeof(flag));
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (!flag[i][j]) {
ch = Puz[i][j];
ok = true;
for (k = 1; k <= n; k++)
if (k != i && Puz[k][j] == ch) {
ok = false;
flag[k][j] = false;
}
for (k = 1; k <= m; k++)
if (k != j && Puz[i][k] == ch) {
ok = false;
flag[i][k] = false;
}
flag[i][j] = ok;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (flag[i][j]) printf("%c", Puz[i][j]);
printf("\n");
}
| 1 |
#include <bits/stdc++.h>
int tree[1000011];
int n, k;
void push(int pos, int val) {
if (pos == 0) return;
while (pos <= n) {
tree[pos] += val;
pos += pos & -pos;
}
return;
}
int get(int pos) {
int ret = 0;
while (pos) {
ret += tree[pos];
pos -= pos & -pos;
}
return ret;
}
int main() {
long long ans = 1;
scanf("%d %d", &n, &k);
if (k * 2 >= n) k = n - k;
int now = 1;
for (int i = 1; i <= n; i++) {
int x = 0;
if (now - k + 1 <= 0) {
x += get(n) - get(now - k + n);
x += get(now - 1);
} else {
x += get(now - 1) - get(now - k);
}
if (now + k > n) {
x += get(n) - get(now);
x += get(now + k - n - 1);
} else
x += get(now + k - 1) - get(now);
ans += x + 1;
printf("%lld ", ans);
push(now, 1);
now += k;
if (now > n) now -= n;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
pair<int, int> temp;
vector<int> ans;
int i, n, v, x, y, cnt = 0, sum = 0;
cin >> n >> v;
priority_queue<pair<int, int> > pq2;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq1;
for (i = 1; i <= n; i++) {
cin >> x >> y;
if (x == 1) {
if (cnt < v) {
++cnt;
pq1.push({y, i});
} else {
if (pq1.top().first < y) {
pq1.pop();
pq1.push({y, i});
}
}
} else
pq2.push({y, i});
}
while (cnt + 2 <= v && !pq2.empty()) {
sum += pq2.top().first;
ans.emplace_back(pq2.top().second);
pq2.pop();
cnt += 2;
}
if (pq2.empty() && cnt <= v) {
while (!pq1.empty()) sum += pq1.top().first, pq1.pop();
cout << sum << '\n';
for (i = 1; i <= n; i++) cout << i << ' ';
return 0;
}
if (cnt < v) pq1.push({0, n + 1});
while (!pq1.empty() && !pq2.empty()) {
temp = pq1.top(), pq1.pop();
if (!pq1.empty() && temp.first + pq1.top().first < pq2.top().first) {
if (pq1.top().first == 0) {
pq1.push(temp);
while (!pq2.empty()) pq2.pop();
break;
}
sum += pq2.top().first;
ans.emplace_back(pq2.top().second);
pq2.pop();
pq1.pop();
} else {
pq1.push(temp);
while (!pq2.empty()) pq2.pop();
}
}
while (!pq1.empty()) {
sum += pq1.top().first;
if (pq1.top().second <= n) ans.emplace_back(pq1.top().second);
pq1.pop();
}
cout << sum << '\n';
for (int idx : ans) cout << idx << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct participant {
string name;
};
const int MAXN = 50 + 10;
participant p[MAXN];
int main() {
int n, sh, uh, a, b, c, d, e, index, maxscore = -10000000;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i].name >> sh >> uh >> a >> b >> c >> d >> e;
int score = 100 * sh - 50 * uh + a + b + c + d + e;
if (score > maxscore) {
maxscore = score;
index = i;
}
}
cout << p[index].name << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int a[N], n, m, maxx[N], dd[N], p[N], ttime, maxxcur[N];
vector<pair<int, pair<int, int> > > Q;
int finds(int u) {
if (p[u] != u) p[u] = finds(p[u]);
return p[u];
}
void combine(int x, int y) {
x = finds(x);
y = finds(y);
if (x != y) maxxcur[y] = max(maxxcur[y], maxxcur[x]), p[x] = y;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (int i = (1), _b = (n); i <= _b; i++)
for (int j = (1), _b = (m); j <= _b; j++) {
cin >> a[((i)*m - m + (j))];
Q.push_back(make_pair(a[((i)*m - m + (j))], make_pair(i, j)));
}
sort(Q.begin(), Q.end());
for (int i = (0), _b = (n * m - 1); i <= _b; i++)
if (!i || Q[i].first != Q[i - 1].first) {
ttime++;
vector<pair<int, int> > v;
for (int j = (i), _b = (n * m - 1); j <= _b; j++)
if (Q[i].first == Q[j].first) {
int x = Q[j].second.first, y = Q[j].second.second;
int cur = max(maxx[x], maxx[n + y]) + 1;
if (dd[x] != ttime)
dd[x] = ttime, p[x] = x, maxxcur[x] = cur;
else
maxxcur[x] = max(maxxcur[x], cur);
if (dd[n + y] != ttime)
dd[n + y] = ttime, p[n + y] = n + y, maxxcur[n + y] = cur;
else
maxxcur[n + y] = max(maxxcur[n + y], cur);
combine(x, n + y);
v.push_back(make_pair(x, y));
} else
break;
for (int j = (0), _b = ((int)v.size() - 1); j <= _b; j++) {
int x = v[j].first, y = v[j].second;
int cur = maxxcur[finds(x)];
a[((x)*m - m + (y))] = cur;
maxx[x] = max(maxx[x], cur), maxx[n + y] = max(maxx[n + y], cur);
}
}
for (int i = (1), _b = (n); i <= _b; i++) {
for (int j = (1), _b = (m); j <= _b; j++)
cout << a[((i)*m - m + (j))] << ' ';
cout << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a >= b) {
return a;
}
return b;
}
long long min(long long a, long long b) {
if (a <= b) {
return a;
}
return b;
}
long long modpower(long long a, long long n, long long d = 1000000007) {
long long res = 1;
while (n) {
if (n % 2) {
res = ((res % d) * (a % d)) % d;
n--;
} else {
a = ((a % d) * (a % d)) % d;
n /= 2;
}
}
return res;
}
long long modadd(long long a, long long b, long long d = 1000000007) {
return ((a % d) + (b % d)) % d;
}
long long modsubtract(long long a, long long b, long long d = 1000000007) {
return ((a % d) - (b % d)) % d;
}
long long modproduct(long long a, long long b, long long d = 1000000007) {
return ((a % d) * (b % d)) % d;
}
void solve() {
long long n, m;
cin >> n >> m;
if (n == 1 && m == 0) {
cout << 0 << " " << 0 << "\n";
return;
}
if (m <= 0 || 9 * n < m) {
cout << -1 << " " << -1 << "\n";
return;
}
string s1(n, '1');
for (long long i = 1; i < n; i++) {
s1[i] = '0';
}
string s2(n, '9');
long long sum = 1;
for (long long i = n - 1; i >= 0; i--) {
if (sum == m) {
break;
}
if (s1[i] == '1') sum = sum - 1;
if (sum + 9 < m) {
s1[i] = '9';
sum += 9;
continue;
}
long long j = 0;
while (j + sum < m) {
j++;
}
s1[i] = 48 + j;
break;
}
sum = 9 * n;
for (long long i = n - 1; i >= 0; i--) {
sum = sum - 9;
if (sum > m) {
s2[i] = '0';
continue;
}
long long j = 0;
while (j + sum < m) {
j++;
}
s2[i] = 48 + j;
break;
}
cout << s1 << " " << s2 << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t > 0) {
t--;
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s[0] == '#') {
cout << -1;
return 0;
}
int l;
int count = 0;
for (int i = 0; i < s.length(); i++)
if (s[i] == '#') {
l = i;
count++;
}
int x = 0;
for (int i = 0; i < l; i++) {
if (x < 0) {
cout << -1;
return 0;
}
if (s[i] == '(')
x++;
else
x--;
}
if (x < 0) {
cout << -1;
return 0;
}
int y = 0;
for (int i = l + 1; i < s.length(); i++)
if (s[i] == '(')
y++;
else
y--;
if (y > 0) {
cout << -1;
return 0;
}
int z = x + y;
if (z <= 0) {
cout << -1;
return 0;
}
x = -y;
for (int i = l + 1; i < s.length(); i++) {
if (x < 0) {
cout << -1;
return 0;
}
if (s[i] == '(')
x++;
else
x--;
}
if (x != 0) {
cout << -1;
return 0;
}
for (int i = 0; i < count - 1; i++) cout << 1 << "\n";
cout << z;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const int mxN = 500001;
int n;
vector<ll> arr;
vector<ll> type;
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n;
arr.resize(n);
type.resize(n);
for (int i = (0); i < (n); ++i) {
cin >> arr[i];
}
for (int i = (0); i < (n); ++i) {
char a;
cin >> a;
if (a == 'G') {
type[i] = 1;
} else if (a == 'W') {
type[i] = 2;
} else {
type[i] = 3;
}
}
ll S = 0;
ll T = 0;
bool watur = false;
ll overg = 0;
ll overw = 0;
for (int i = (0); i < (n); ++i) {
if (type[i] == 1) {
S += arr[i];
overg += 2 * arr[i];
T += 5 * arr[i];
} else if (type[i] == 2) {
S += arr[i];
T += 3 * arr[i];
overw += arr[i];
watur = true;
} else {
if (S >= arr[i]) {
S -= arr[i];
T += arr[i];
} else {
if (watur) {
T += arr[i] + 3 * (arr[i] - S);
} else {
T += arr[i] + 5 * (arr[i] - S);
}
S = 0;
}
}
overg = min(overg, S);
}
if (S > 0) {
T -= 2 * overg;
T -= ((S - overg));
}
cout << T << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxRounds = 200000;
double p[110], ans, pw[110][maxRounds + 10];
int times[110], n;
int main() {
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
for (int i = 1; i <= n; ++i) {
int first;
cin >> first;
p[i] = first / 100.0;
}
double initProd = 1;
for (int i = 1; i <= n; ++i) {
initProd *= p[i];
pw[i][0] = 1;
times[i] = 1;
for (int j = 1; j <= maxRounds; ++j) {
pw[i][j] = pw[i][j - 1] * (1 - p[i]);
}
}
ans += initProd * n;
for (int round = n + 1; round <= maxRounds; ++round) {
double best = 0;
int besti = 1;
double prod = 1;
for (int j = 1; j <= n; ++j) prod *= (1 - pw[j][times[j]]);
for (int j = 1; j <= n; ++j) {
double current = prod / (1 - pw[j][times[j]]) * pw[j][times[j]] * p[j];
if (current > best) {
besti = j;
best = current;
}
}
ans += best * round;
times[besti]++;
}
cout << fixed << setprecision(8) << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long b[4] = {1, 5, 10, 50};
long long n;
set<long long> s;
void dfs(long long x, long long cnt) {
if (cnt == n + 1) {
s.insert(x);
return;
}
for (long long i = 0; i < 4; i++) {
dfs(x + b[i], cnt + 1);
}
}
long long a[25] = {0, 4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292};
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
if (n <= 11) {
cout << a[n] << endl;
} else {
long long ans = a[11] + (n - 11) * 49;
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010, mod = 1e9 + 7, INF = 0x3f3f3f3f;
const double eps = 1e-6;
int n;
int a[N], pos[N];
int pre[N][210];
vector<int> v[210];
int solve() {
int ans = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 200; j++)
pre[i][j] = pre[i - 1][j] + (a[i] == j), ans = max(ans, pre[i][j]);
for (int i = 1; i <= n; i++) {
int val = a[i];
pos[val]++;
if (pos[val] * 2 > (int)v[val].size()) continue;
int cnt = pos[val] * 2;
int st = i + 1, ed = v[val][v[val].size() - pos[val]] - 1;
int add = 0;
for (int j = 1; j <= 200; j++)
if (ed >= st - 1) add = max(add, pre[ed][j] - pre[st - 1][j]);
ans = max(ans, cnt + add);
}
return ans;
}
int main() {
int _;
scanf("%d", &_);
while (_--) {
scanf("%d", &n);
for (int i = 0; i <= 200; i++) pos[i] = 0, v[i].clear();
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), v[a[i]].push_back(i);
printf("%d\n", solve());
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
if (n % 2 == 0) {
vector<pair<long long, long long> > pairs;
long long i1 = 1;
long long j1 = n;
while (i1 < j1) {
pairs.push_back(make_pair(i1, j1));
i1++;
j1--;
}
for (long long i = 0; i < pairs.size(); i++) {
long long f = 1;
long long s = m;
while (s > 0) {
printf("%lld %lld\n", pairs[i].first, f);
printf("%lld %lld\n", pairs[i].second, s);
f++;
s--;
}
}
} else {
vector<pair<long long, long long> > pairs;
long long i1 = 1;
long long j1 = n;
while (i1 < j1) {
pairs.push_back(make_pair(i1, j1));
i1++;
j1--;
}
long long left = (n + 1) / 2;
for (long long i = 0; i < pairs.size(); i++) {
long long f = 1;
long long s = m;
while (s > 0) {
printf("%lld %lld\n", pairs[i].first, f);
printf("%lld %lld\n", pairs[i].second, s);
f++;
s--;
}
}
long long l = 1;
long long r = m;
long long x = l;
while (l <= r) {
printf("%lld %lld\n", left, x);
if (x == l) {
x = r;
l++;
} else {
x = l;
r--;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void flash() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
long long pw(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long ans = pw(x, y / 2);
ans = ans * ans;
if (y % 2 == 1) ans = ans * x;
return ans;
}
long long pwm(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long ans = pwm(x, y / 2) % 998244353;
ans = (ans * ans) % 998244353;
if (y % 2 == 1) ans = (ans * x) % 998244353;
return ans;
}
int check(long long n) {
if (n < 0)
return 0;
else
return 1;
}
long long add(long long a, long long b) { return a + b; }
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a > b)
return b;
else
return a;
}
long long minv(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m, t = m;
m = a % m, a = t, t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
bool cmp(long long i1, long long i2) { return (i1 < i2); }
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> a(m);
long long sum = 0;
for (int i = 0; i < m; ++i) {
cin >> a[i];
sum += a[i];
}
vector<long long> b = a;
if (sum < n) {
cout << -1 << "\n";
return;
}
long long flag = sum - n;
for (int i = 0; i < m; ++i) {
int free = min(flag, a[i] - 1);
flag -= free;
a[i] -= free;
}
long long pos = 1;
vector<long long> ans;
for (int i = 0; i < m; ++i) {
if (pos > n - b[i] + 1) {
cout << -1 << "\n";
return;
}
ans.push_back(pos);
pos += a[i];
}
for (auto &c : ans) cout << c << " ";
}
int main() {
flash();
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> c;
int n;
vector<vector<int> > g;
bool used[3001];
bool cyc[3001];
bool findC;
vector<int> cl;
vector<int> p;
int cycle_st, cycle_end;
void dfs(int k, int root, int parent, vector<int> gr) {
if (parent != k && root == k) {
findC = true;
c = gr;
return;
}
gr.push_back(k);
if (root != k) used[k] = true;
for (vector<int>::iterator i = g[k].begin(); i != g[k].end(); ++i) {
if (*i != parent && !used[*i]) {
dfs(*i, root, k, gr);
if (findC) return;
}
}
}
bool dfs3(int v, int parent) {
cl[v] = 1;
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (to == parent) continue;
if (cl[to] == 0) {
p[to] = v;
if (dfs3(to, v)) return true;
} else if (cl[to] == 1) {
cycle_end = v;
cycle_st = to;
return true;
}
}
cl[v] = 2;
return false;
}
bool dfs2(int k, int step) {
if (cyc[k]) {
cout << step << " ";
return true;
}
used[k] = true;
for (vector<int>::iterator i = g[k].begin(); i != g[k].end(); ++i) {
if (!used[*i]) {
if (dfs2(*i, step + 1)) return true;
}
}
return false;
}
int main(int argc, const char* argv[]) {
cin >> n;
vector<int> temp;
g.assign(n, temp);
for (int i = 0; i < n; i++) {
int k1;
cin >> k1;
int k2;
cin >> k2;
g[k1 - 1].push_back(k2 - 1);
g[k2 - 1].push_back(k1 - 1);
}
p.assign(n, -1);
cl.assign(n, 0);
cycle_st = -1;
for (int i = 0; i < n; ++i)
if (dfs3(i, i)) break;
cyc[cycle_st] = true;
for (int v = cycle_end; v != cycle_st; v = p[v]) {
cyc[v] = true;
}
for (int i = 0; i < n; i++) {
std::fill_n(used, n, false);
dfs2(i, 0);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<int> fst, scd;
int arr[100009];
int n;
int cnt[100009];
int main() {
long long ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
scd.insert(arr[i]);
cnt[arr[i]]++;
}
for (int i = 1; i <= n; i++) {
if (fst.find(arr[i]) != fst.end()) {
cnt[arr[i]]--;
if (cnt[arr[i]] == 0) scd.erase(arr[i]);
continue;
}
fst.insert(arr[i]);
cnt[arr[i]]--;
if (cnt[arr[i]] == 0) scd.erase(arr[i]);
ans += scd.size();
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a, b, zefr;
cin >> a >> b;
cout << a + b;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
srand(time(0));
cout << fixed << setprecision(7);
cerr << fixed << setprecision(7);
static int A[55][55];
static int B[55][55];
long long T;
cin >> T;
vector<int> ans;
while (T) ans.push_back(T % 3), T /= 3;
int sz = ans.size();
for (int i = 0; i < sz; ++i) {
int N = 3 + i;
if (!ans[i])
A[N][N - 2] = 1, B[N - 2][N] = 1;
else if (ans[i] == 1)
A[N][N - 2] = 1;
if (i != sz - 1) B[N + 1][N - 2] = A[N - 2][N + 1] = 1;
if (i == sz - 1) A[N][N - 1] = A[N][N] = B[N][N] = B[N - 1][N] = 1;
}
int n = 3 + sz;
for (int i = 5; i < n; ++i)
A[i - 4][i + 1] = B[i - 4][i] = B[i + 1][i - 4] = A[i][i - 4] = 1;
cout << n << ' ' << n << '\n';
set<vector<int> > S;
static long long D[55][55];
D[1][1] = 1;
for (int i = 1; i < n; ++i)
for (int j = 1; j <= n; ++j)
if (A[i][j]) S.insert({i, j, i + 1, j});
for (int i = 1; i <= n; ++i)
for (int j = 1; j < n; ++j)
if (B[i][j]) S.insert({i, j, i, j + 1});
cout << S.size() << '\n';
for (auto it : S)
cout << it[0] << ' ' << it[1] << ' ' << it[2] << ' ' << it[3] << '\n';
cerr << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms"
<< '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
static char buff[(int)1e6 + 17];
static constexpr long long inf = (long long)1e9 + 7ll;
inline void config_io(const bool& __fastio) {
if (__fastio) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
}
if (!std::string("").empty()) {
assert(
freopen(""
".in",
"r", stdin));
assert(
freopen(""
".out",
"w", stdout));
}
}
using namespace std;
const int maxn = (int)1e6 + 17;
int n, maxsymb = 3;
string text_s;
int text[maxn], suff[maxn], c[maxn];
pair<pair<int, int>, int> p[maxn];
int lcp[maxn], pos[maxn];
int st[19][maxn], lg[maxn];
vector<int> ids[2 * maxn];
int bal[maxn];
void build() {
for (int i = 0; i < n; ++i) c[i] = text[i];
for (int h = 0; h < 19; ++h) {
for (int i = 0; i < n; ++i) p[i] = {{c[i], c[i + (1 << h)]}, i};
sort(p, p + n);
int cnt = 0;
for (int i = 0; i < n; ++i) {
c[p[i].second] = cnt;
cnt += p[i].first != p[i + 1].first;
}
if (cnt == n) break;
}
for (int i = 0; i < n; ++i) suff[c[i]] = i;
}
void kasai() {
for (int i = 0; i < n; ++i) pos[suff[i]] = i;
int k = 0;
for (int i = 0; i < n; ++i) {
k = max(0, k - 1);
if (pos[i] == n - 1)
lcp[pos[i]] = -1;
else {
int j = suff[pos[i] + 1];
for (; max(i, j) + k < n && text[i + k] == text[j + k]; ++k)
;
lcp[pos[i]] = k;
}
}
}
void build_st() {
for (int i = 1, l = 0; i <= n; ++i) {
l += ((1 << (l + 1)) == i);
lg[i] = l;
}
for (int i = 0; i < n - 1; ++i) st[0][i] = bal[i];
for (int k = 1; k <= lg[n - 1]; ++k)
for (int i = 0; i + (1 << (k - 1)) < n - 1; ++i)
st[k][i] = min(st[k - 1][i], st[k - 1][i + (1 << (k - 1))]);
}
int getmin(int l, int r) {
int k = lg[r - l + 1];
return min(st[k][l], st[k][r - (1 << k) + 1]);
}
int getlower(int l, int r, int b) {
if (l > r) return 0;
int lf = lower_bound(ids[b].begin(), ids[b].end(), l) - ids[b].begin();
int rg = lower_bound(ids[b].begin(), ids[b].end(), r) - ids[b].begin();
if (rg < ((int)ids[b].size()) && ids[b][rg] == r) ++rg;
return rg - lf;
}
int main() {
config_io(false);
scanf("%d", &n);
n = 0;
int id = 0;
while (scanf("%s", buff) == 1) {
string t = string(buff);
for (int i = 0, b = maxn; i < ((int)t.size()); ++i) {
text[n++] = 1 + t[i] - '(';
b += (t[i] == '(') - (t[i] == ')');
ids[b].push_back(i);
bal[i] = b;
}
text_s += t + "#";
text[n++] = id++;
}
build();
kasai();
build_st();
long long ans = 0ll;
for (int i = 1; i < n; ++i)
if (text_s[suff[i]] == '(') {
int j = suff[i], l = lcp[i - 1], lf, rg;
for (lf = j, rg = n - 2; lf < rg;) {
int m = (lf + rg + 1) / 2;
if (getmin(j, m) >= bal[j] - 1)
lf = m;
else
rg = m - 1;
}
ans += getlower(j + l, rg, bal[j] - 1);
} else
break;
printf("%I64d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
register char c = getchar();
x = 0;
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) + c - '0';
}
int main() {
int n, x;
long long t, a = 0, b = 0, c = 0, z = 0;
read(n);
while (--n) {
read(x);
if (x > 1) {
if (x & 1) {
c = max(a, c) + x - 1;
a = max(a, b) + x;
b += x - 1;
} else {
c = max(a, c) + x;
a = max(a, b) + x - 1;
b += x;
}
} else {
if (x & 1)
a = max(a, b) + x;
else
a = max(a, b) + x - 1;
b = c = 0;
}
z = max(max(z, a), max(b, c));
}
cout << z;
}
| 6 |
#include <bits/stdc++.h>
const int mod = 998244353;
char S[1500010];
int N[1500010], A[1 << 21], n, len;
long long pw(long long a, int n = mod - 2) {
long long b = 1;
for (; n; n >>= 1) n % 2 ? b = b * a % mod : 1, a = a * a % mod;
return b;
}
int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
int sub(int a, int b) { return a - b < 0 ? a - b + mod : a - b; }
int ws[1 << 21];
void dft(int* a, int n, bool r = 0) {
int* w = ws + n / 2;
w[0] = 1;
w[1] = pw(3, (mod - 1) / n);
if (r) w[1] = pw(w[1]);
for (int i = 2; i < n / 2; i++) w[i] = w[i - 1] * (long long)w[1] % mod;
for (int i = n / 2; --i;) ws[i] = ws[i * 2];
w = ws + 1;
for (int i = 0, j = 0, t; i < n; i++) {
if (i < j) t = a[i], a[i] = a[j], a[j] = t;
for (t = n / 2; (j ^= t) < t; t /= 2)
;
}
for (int i = 1; i < n; w += i, i *= 2)
for (int j = 0; j < n; j += i << 1)
for (int k = 0, t; k < i; k++) {
t = a[i + j + k] * (long long)w[k] % mod;
a[i + j + k] = sub(a[j + k], t);
a[j + k] = add(a[j + k], t);
}
if (r) {
long long I = pw(n);
for (int i = 0; i < n; i++) a[i] = a[i] * I % mod;
}
}
void car(int* a, int& n) {
for (; n && !a[n - 1]; n--)
;
}
void sqr() {
int k = 1;
while (k < n * 2) k *= 2;
dft(A, k);
for (int i = 0; i < k; i++) A[i] = 1ll * A[i] * A[i] % mod;
dft(A, k, 1);
for (int i = 0; i < k; i++) A[i + 1] += A[i] / 10, A[i] %= 10;
car(A, n *= 2);
}
void mul() {
for (int i = 0, c = 0; i <= n; i++) A[i] = (c += A[i] * 3) % 10, c /= 10;
car(A, ++n);
}
void div(int* a, int& n, int b) {
for (int i = n, c = 0; i--;) a[i] = (c = c * 10 + a[i]) / b, c %= b;
car(a, n);
}
void add() {
N[0]++;
for (int i = 0; N[i] > 9; i++) N[i + 1]++, N[i] = 0;
car(N, ++len);
}
bool lt() {
if (n != len) return n < len;
for (int i = n; i--;)
if (A[i] != N[i]) return A[i] < N[i];
return 0;
}
int main() {
scanf("%s", S);
len = strlen(S);
for (int i = 0; i < len; i++) N[len - i - 1] = S[i] - '0';
A[0] = n = 1;
int m = len * log(10) / log(3) + 1, i = 0;
while (m >> i) i++;
while (i--) sqr(), m >> i & 1 ? mul(), 1 : 1;
while (!lt()) div(A, n, 3), m--;
int ans = m < 0 ? 1 : (m + 1) * 3;
for (int t = 1; t <= 2; t++) {
add();
div(N, len, 2);
while (!lt()) div(A, n, 3), m--;
if ((m + 1) * 3 + t * 2 < ans) ans = (m + 1) * 3 + t * 2;
}
printf("%d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, o, f = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
o = n - 1;
for (int i = n - 1; i >= 0; i--) {
if (a[i] > a[i - 1]) {
o--;
} else {
cout << o << endl;
return 0;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int l, k, multx = 1, num = 0;
cin >> l;
string second;
bool flag = 1;
long long int N = pow(2, 32) - 1, c;
deque<long long int> dq;
dq.push_back(1);
for (long long int i = 0; i < l; i++) {
cin >> second;
if (second == "for") {
cin >> k;
if (dq.empty())
dq.push_back(k);
else {
c = dq.back() * k;
if (c > N or c < 0)
dq.push_back(-1);
else
dq.push_back(c);
}
} else if (second == "add") {
if (dq.empty())
num++;
else {
num += dq.back();
if (dq.back() < 0 or num > N) flag = 0;
}
} else
dq.pop_back();
}
if (num < 0 or num > N) flag = 0;
flag ? cout << num << endl : cout << "OVERFLOW!!!\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, t[111111];
void upd(int x, int val) {
for (int i = x; i <= n; i = (i | (i + 1))) {
t[i] += val;
}
}
int get(int x) {
int res = 0;
for (int i = x; i > 0; i = (i & (i + 1)) - 1) {
res += t[i];
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
upd(i, x);
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
int sum = (get(r) - get(l - 1));
cout << sum / 10 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[100001];
int a[100];
int main() {
int T, n;
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n; i++) {
a[s[i] - 'a']++;
}
int judge = 0;
int count = 0;
for (int i = 0; i < 26; i++) {
if (a[i] == 1) {
judge++;
} else if (a[i] > 1) {
count++;
}
}
if (judge == 1 && count == 0) {
printf("YES\n");
return 0;
}
if (count == 0) {
printf("NO\n");
} else {
printf("YES\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int k, b, n, t;
cin >> k >> b >> n >> t;
long long int x = 1;
if (t == 1)
cout << n;
else {
int m = 0;
for (long long int i = 1; i <= n; i++) {
x = x * k + b;
if (x > t) {
cout << (n - i + 1);
m = 1;
break;
}
}
if (m == 0) cout << "0";
}
}
| 4 |
#include <bits/stdc++.h>
bool my_cmp(const std::pair<int, int> &p1, const std::pair<int, int> &p2) {
return p1.second - p1.first > p2.second - p2.first;
}
int main() {
std::ios::sync_with_stdio(false);
int n, k, i, x;
std::cin >> n >> k;
std::vector<int> before(n);
std::vector<std::pair<int, int>> pairs(n);
for (i = 0; i < n; ++i) {
std::cin >> before[i];
}
for (i = 0; i < n; ++i) {
std::cin >> x;
pairs[i] = std::make_pair(before[i], x);
}
int sum = 0;
std::sort(pairs.begin(), pairs.end(), my_cmp);
for (i = 0; i < k; ++i) {
sum += pairs[i].first;
}
for (i = k; i < n; ++i) {
sum += std::min(pairs[i].second, pairs[i].first);
}
std::cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf_int = 1e9 + 100;
const long long inf_ll = 1e18;
const double pi = 3.1415926535898;
template <class T1, class T2>
std::ostream &operator<<(std::ostream &out, const std::pair<T1, T2> &rhs) {
out << "( " << rhs.first << " , " << rhs.second << " )";
return out;
}
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A>
string to_string(vector<vector<A>> v) {
bool first = true;
string res = "\n{";
for (const auto &x : v) {
if (!first) {
res += ",\n ";
}
first = false;
res += to_string(x);
}
res += "}\n";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
bool debug = 0;
const int MAXN = 1 << 18;
const int LOG = 20;
const int mod = 998244353;
const int MX = (2e4 + 100);
vector<int> ids[MAXN];
int parent[MAXN];
int get_parent(int v) {
if (v == parent[v]) return v;
return parent[v] = get_parent(parent[v]);
}
mt19937 mt(228);
bool union_set(int a, int b) {
a = get_parent(a);
b = get_parent(b);
if (a != b) {
if (mt() & 1) swap(a, b);
parent[a] = b;
return true;
}
return false;
}
int cnt[MAXN];
bool used[MAXN];
void solve() {
int n;
cin >> n;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
cnt[x]++;
ans -= x;
}
cnt[0]++;
for (int i = 0; i < (1 << 18); ++i) {
parent[i] = i;
}
for (int mask = (1 << 18) - 1; mask >= 0; --mask) {
for (int sub = mask;; sub = (sub - 1) & mask) {
int u = sub;
int v = mask ^ sub;
if (cnt[u] && cnt[v]) {
if (union_set(u, v)) {
int val;
if (used[u] && used[v]) {
val = 1;
} else if (used[u]) {
val = cnt[v];
} else if (used[v]) {
val = cnt[u];
} else {
val = cnt[v] + cnt[u] - 1;
}
ans += 1ll * val * mask;
}
used[u] = used[v] = true;
}
if (sub == 0) break;
}
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(15);
int t = 1;
while (t--) solve();
42;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int idx1_len, idx2_len;
cin >> idx1_len >> idx2_len;
int idx1__idx2___value[idx1_len][idx2_len];
int idx1___white_nr[idx1_len];
int idx2___white_nr[idx2_len];
for (int idx1 = 0; idx1 < idx1_len; idx1++) {
idx1___white_nr[idx1] = 0;
}
for (int idx2 = 0; idx2 < idx2_len; idx2++) {
idx2___white_nr[idx2] = 0;
}
for (int idx1 = 0; idx1 < idx1_len; idx1++) {
for (int idx2 = 0; idx2 < idx2_len; idx2++) {
cin >> idx1__idx2___value[idx1][idx2];
if (idx1__idx2___value[idx1][idx2] == 0) {
idx1___white_nr[idx1]++;
idx2___white_nr[idx2]++;
}
}
}
long long ans = 0;
long long one = 1;
for (int idx1 = 0; idx1 < idx1_len; idx1++) {
ans += (one << idx1___white_nr[idx1]) - 1;
ans += (one << (idx2_len - idx1___white_nr[idx1])) - 1;
}
for (int idx2 = 0; idx2 < idx2_len; idx2++) {
ans += (one << idx2___white_nr[idx2]) - 1;
ans += (one << (idx1_len - idx2___white_nr[idx2])) - 1;
}
ans -= idx1_len * idx2_len;
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int t, i, j, c, s, a, zero, one;
string test;
cin >> t;
while (t--) {
cin >> test;
zero = one = 0;
for (i = 0; i < test.size(); i++) {
if (test[i] == '1')
one++;
else
zero++;
}
a = min(zero, one);
c = s = 0;
for (i = 0; i < test.size(); i++) {
if (test[i] == '1') {
one--;
c++;
} else {
zero--;
s++;
}
a = min(a, zero + c);
a = min(a, one + s);
}
cout << a << '\n';
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.