solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1 << 30;
int main() {
int n, m;
cin >> n >> m;
string str;
cin >> str;
int l, r;
char c1, c2;
for (int i = 0; i < m; i++) {
cin >> l >> r >> c1 >> c2;
for (int j = l - 1; j <= r - 1; j++) {
if (c1 == str[j]) {
str[j] = c2;
}
}
}
cout << str;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int v[400][400][10][30];
bool z[500][500];
int n, t[50];
int a[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int b[] = {0, 1, -1, 1, -1, 1, -1, 0};
int ri[10];
int le[10];
void dfs(int x, int y, int k = 0, int i = 0) {
if (v[x + 200][y + 200][k][i]) {
return;
}
if (i == n) return;
v[x + 200][y + 200][k][i] = 1;
for (int j = 0; j < t[i]; j++) {
z[x + j * a[k] + 200][y + j * b[k] + 200] = 1;
}
dfs(x + (t[i] - 1) * a[k] + a[le[k]], y + (t[i] - 1) * b[k] + b[le[k]], le[k],
i + 1);
dfs(x + (t[i] - 1) * a[k] + a[ri[k]], y + (t[i] - 1) * b[k] + b[ri[k]], ri[k],
i + 1);
}
int main() {
le[0] = 1;
ri[0] = 2;
le[1] = 0;
ri[1] = 3;
le[2] = 0;
ri[2] = 4;
le[3] = 1;
ri[3] = 5;
le[4] = 2;
ri[4] = 6;
le[5] = 3;
ri[5] = 7;
le[6] = 4;
ri[6] = 7;
le[7] = 5;
ri[7] = 6;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t[i];
}
dfs(0, 0);
long long res = 0;
for (int i = 0; i < 400; i++) {
for (int j = 0; j < 400; j++) {
if (z[i][j]) res++;
}
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
cin >> a >> b;
n = abs(a - b) / 2;
if ((a - b) % 2 == 0)
cout << n * (n + 1);
else
cout << (n + 1) * (n + 1);
return 0;
}
| 1 |
#include <iostream>
#include <set>
#include <cstring>
using namespace std;
int n;
int main() {
while (cin >> n, n != 0) {
set<int> mod;
for (int i = 1; i < n; i++)
mod.insert( (i*i) % n );
int count[(n-1)/2+1];
memset(count, 0, sizeof(count));
for (set<int>::iterator si = mod.begin();
si != mod.end(); si++) {
for (set<int>::iterator sj = mod.begin();
sj != mod.end(); sj++) {
if (*si == *sj) continue;
int dif = *si - *sj;
if (dif < 0) dif += n;
if (dif > (n-1)/2) dif = n - dif;
count[dif]++;
}
}
for (int i = 1; i <= (n-1)/2; i++)
cout << count[i] << endl;
}
return 0;
}
| 0 |
//ceil(a/b) is equal to (a+b-1)/b
#include<bits/stdc++.h>
#define mx(a) *max_element(all(a))
#define mn(a) *min_element(all(a))
#define int long long int
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define vec vector <int>
#define pr vector<pair<int,int>>
#define vecv vector <vec>
#define vecs vector <string>
#define vecc vector <char>
#define pi 3.141592653589793238
#define mod 1000000007
#define Mod 998244353
#define inf 1e16
#define precise(i) fixed << setprecision(10) << i
#define endl "\n"
#define yes cout<<"YES"<<endl;
#define no cout<<"NO"<<endl;
#define one cout<<-1<<endl;
#define err1(a) cout<<#a<<" "<<a<<endl;
#define err2(a,b) cout<<#a<<" "<<a<<" "<<#b<<" "<<b<<endl;
#define err3(a,b,c) cout<<#a<<" "<<a<<" "<<#b<<" "<<b<<" "<<#c<<" "<<c<<endl;
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define all(a) a.begin(),a.end()
#define show(a) for(auto xyz:a)cout<<xyz<<" ";cout<<endl;
#define show_nl(a) for(auto xyz:a)cout<<xyz<<endl;
#define loop(a) for(auto xyz:a)
#define f(i,a,b) for(int i=a;i<b;i++)
#define rf(i,a,b) for(int i=b;i>=a;i--)
const long double eps = 1e-8;
#define lb lower_bound //THIS GIVES THE ITR TO THE ELEMENT IN RANGE [SI,EI) THAT IS >= OUR VALUE
#define ub upper_bound //THIS GIVES THE ITR TO THE ELEMENT IN RANGE [SI,EI) THAT IS > OUR VALUE
using namespace std;
signed main() {
fastio
int t=1;
cin>>t;
while(t--)
{
int n;
cin>>n;
vecs s1(n),s2(n);
for(auto &i:s1)
cin>>i;
for(auto &i:s2)
cin>>i;
f(i,0,n)
{
if(s1[0][i]!=s2[0][i])
{
f(j,0,n)
{
if(s1[j][i]=='0') s1[j][i]='1';
else s1[j][i]='0';
}
}
}
f(i,0,n)
{
if(s1[i][0]!=s2[i][0])
{
f(j,0,n)
{
if(s1[i][j]=='0') s1[i][j]='1';
else s1[i][j]='0';
}
}
}
int f1=0;
f(i,0,n)
{
f(j,0,n) if(s1[i][j]!=s2[i][j]) f1=1;
}
if(f1) no
else yes
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool sieve[2000006];
int fprime[2000006];
vector<int> divset;
void primeTable() {
int i, j;
int lim = sqrt((double)2000006) + 6;
memset(fprime, -1, sizeof(fprime));
fprime[2] = 2;
for (i = 4; i < 2000006; i += 2) sieve[i] = true, fprime[i] = 2;
for (i = 3; i < lim; i += 2) {
if (!sieve[i]) {
fprime[i] = i;
for (j = i * i; j < 2000006; j += (i << 1)) {
sieve[j] = true;
if (fprime[j] == -1) fprime[j] = i;
}
}
}
for (; i < 2000006; i += 2) {
if (!sieve[i]) fprime[i] = i;
}
}
void factor(int N, vector<int> &ppf) {
ppf.clear();
int p = fprime[N], f = 0;
while (N != 1) {
p = fprime[N], f = 0;
while (fprime[N] == p) {
++f;
N /= p;
}
ppf.push_back(p);
}
}
vector<int> Edges[100006], sofar[2000006];
int level[100006], val[100006], ans[100006];
void dfs(int p, int n, int l) {
level[n] = l;
int i;
for (i = 0; i < Edges[n].size(); ++i) {
if (Edges[n][i] == p) continue;
dfs(n, Edges[n][i], l + 1);
}
}
void takecare(int n, vector<int> &ppf) {
int i, p, a = -1;
for (i = 0; i < ppf.size(); ++i) {
p = ppf[i];
if (sofar[p].size() == 0) continue;
if (a == -1 || level[sofar[p].back()] > level[a]) a = sofar[p].back();
}
ans[n] = a;
}
void add(int n, vector<int> &ppf) {
int i;
for (i = 0; i < ppf.size(); ++i) sofar[ppf[i]].push_back(n);
}
void del(vector<int> &ppf) {
int i;
for (i = 0; i < ppf.size(); ++i) sofar[ppf[i]].pop_back();
}
void update(int p, int n) {
vector<int> ppf;
factor(val[n], ppf);
takecare(n, ppf);
add(n, ppf);
int i;
for (i = 0; i < Edges[n].size(); ++i) {
if (Edges[n][i] != p) update(n, Edges[n][i]);
}
del(ppf);
}
int main() {
primeTable();
int N, Q, i, j, op, x, y;
vector<int> ppf;
while (scanf("%d %d", &N, &Q) != EOF) {
for (i = 1; i <= N; ++i) {
scanf("%d", &val[i]);
Edges[i].clear();
factor(val[i], ppf);
for (j = 0; j < ppf.size(); ++j) sofar[ppf[j]].clear();
}
for (i = 1; i < N; ++i) {
scanf("%d %d", &x, &y);
Edges[x].push_back(y);
Edges[y].push_back(x);
}
dfs(-1, 1, 1);
update(-1, 1);
while (Q--) {
scanf("%d %d", &op, &x);
if (op == 1)
printf("%d\n", ans[x]);
else {
scanf("%d", &val[x]);
update(-1, 1);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int a[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if ((i + j) & 1)
a[i][j] = (a[i][j] & 1) ? a[i][j] : a[i][j] + 1;
else
a[i][j] = (a[i][j] & 1) ? a[i][j] + 1 : a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << a[i][j] << " ";
cout << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int indg[121212];
vector<int> edge[121212];
int par[121212];
void dfs(int w, int bef) {
int i;
par[w] = bef;
indg[bef]++;
for (i = 0; i < edge[w].size(); i++) {
int nxt = edge[w][i];
if (nxt == bef) continue;
dfs(nxt, w);
}
}
int main() {
int n;
scanf("%d", &n);
int i, j, k;
int w, mx;
for (i = 0; i < n - 1; i++) {
int s, e;
scanf("%d%d", &s, &e);
edge[s].push_back(e);
edge[e].push_back(s);
}
mx = 0;
for (i = 1; i <= n; i++) {
if (mx < edge[i].size()) {
mx = edge[i].size();
w = i;
}
}
dfs(w, 0);
vector<int> ans;
for (i = 1; i <= n; i++) {
if (i == w) continue;
if (indg[i] >= 2) {
printf("No");
return 0;
}
if (indg[i] == 0) ans.push_back(i);
}
printf("Yes\n");
printf("%d\n", ans.size());
for (i = 0; i < ans.size(); i++) {
printf("%d %d\n", w, ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s[11];
int len[11], id[11];
vector<string> ans;
void upd(vector<string> &cur) {
if (!ans.size()) {
ans = cur;
return;
}
for (int i = 0; i < (int)ans.size(); i++) {
if (cur[i] < ans[i]) break;
if (cur[i] > ans[i]) return;
}
ans = cur;
}
int main() {
for (int i = 0; i < 6; i++) {
cin >> s[i];
len[i] = s[i].length();
}
for (int i = 0; i < 6; i++) id[i] = i;
do {
if (len[id[0]] + len[id[2]] != len[id[1]] + 1) continue;
if (len[id[3]] + len[id[5]] != len[id[4]] + 1) continue;
if (s[id[0]][0] != s[id[3]][0]) continue;
if (s[id[0]][len[id[0]] - 1] != s[id[4]][0]) continue;
if (s[id[1]][0] != s[id[3]][len[id[3]] - 1]) continue;
if (s[id[1]][len[id[0]] - 1] != s[id[4]][len[id[3]] - 1]) continue;
if (s[id[1]][len[id[1]] - 1] != s[id[5]][0]) continue;
if (s[id[2]][0] != s[id[4]][len[id[4]] - 1]) continue;
if (s[id[2]][len[id[2]] - 1] != s[id[5]][len[id[5]] - 1]) continue;
vector<string> cur;
cur.clear();
string t = s[id[0]];
for (int i = len[id[0]]; i < len[id[1]]; i++) t += '.';
cur.push_back(t);
for (int i = 1; i < len[id[3]] - 1; i++) {
t = s[id[3]][i];
for (int j = 1; j < len[id[0]] - 1; j++) t += '.';
t += s[id[4]][i];
for (int j = len[id[0]]; j < len[id[1]]; j++) t += '.';
cur.push_back(t);
}
cur.push_back(s[id[1]]);
for (int i = len[id[3]]; i < len[id[4]] - 1; i++) {
t = "";
for (int j = 0; j < len[id[0]] - 1; j++) t += '.';
t += s[id[4]][i];
for (int j = 1; j < len[id[2]] - 1; j++) t += '.';
t += s[id[5]][i - len[id[3]] + 1];
cur.push_back(t);
}
t = "";
for (int i = 0; i < len[id[0]] - 1; i++) t += '.';
t += s[id[2]];
cur.push_back(t);
upd(cur);
} while (next_permutation(id, id + 6));
if (!ans.size())
cout << "Impossible" << endl;
else {
for (int i = 0; i < (int)ans.size(); i++) cout << ans[i] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 1e5 + 5;
int n, len = 1, a[maxn], st[4 * maxn];
void compress() {
set<int> s;
map<int, int> ids;
for (int i = 0; i < n; i++) s.insert(a[i]);
for (int x : s) ids[x] = len++;
for (int i = 0; i < n; i++) a[i] = ids[a[i]];
}
void upd(int i, int v, int pos = 1, int l = 0, int r = n) {
if (l == r) {
st[pos] = max(st[pos], v);
return;
}
int mid = (l + r) / 2;
if (i <= mid)
upd(i, v, 2 * pos, l, mid);
else
upd(i, v, 2 * pos + 1, mid + 1, r);
st[pos] = max(st[2 * pos], st[2 * pos + 1]);
}
int query(int ql, int qr, int pos = 1, int l = 0, int r = n) {
if (ql <= l && r <= qr) return st[pos];
if (r < ql or l > qr) return -1;
int mid = (l + r) / 2;
return max(query(ql, qr, 2 * pos, l, mid),
query(ql, qr, 2 * pos + 1, mid + 1, r));
}
int main() {
memset(st, -1, sizeof(st));
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
compress();
for (int i = n - 1; i >= 0; i--) {
int v = query(0, a[i] - 1);
upd(a[i], i);
if (v == -1)
a[i] = v;
else
a[i] = v - i - 1;
}
for (int i = 0; i < n; i++) printf("%d%c", a[i], " \n"[i + 1 == n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double fac[200005], ln[200005];
inline double Poi(int x, int P) {
x += P;
return x * ln[P] - P - fac[x];
}
inline double Uni(int x, int P) {
x += P;
if (x < 0 || x > 2 * P) return -1e20;
return -ln[2 * P + 1];
}
const int N = 255;
int T;
int a[N];
int main() {
int T;
scanf("%d", &(T));
fac[0] = 0;
for (int i = 1; i <= 200000; i++) fac[i] = fac[i - 1] + (ln[i] = log(i));
while (T--) {
for (int i = 1; i <= 250; i++) scanf("%d", &(a[i]));
int t = -1, P = -1;
double maxv = -1e20;
for (int p = 1; p <= 1000; p++) {
double ret = 0;
for (int i = 1; i <= 250; i++) ret += Poi(a[i], p);
if (ret > maxv) maxv = ret, t = 0, P = p;
ret = 0;
for (int i = 1; i <= 250; i++) ret += Uni(a[i], p);
if (ret > maxv) maxv = ret, t = 1, P = p;
}
if (t == 0)
printf("poisson\n");
else
printf("uniform\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
static long long other_try(std::vector<int>& attacking,
const std::vector<int>& attack_pos,
const std::vector<int>& def_pos) {
std::sort(attacking.begin(), attacking.end());
long long ret = 0;
for (int i = 0; i < def_pos.size(); i++) {
if (attacking.size() == 0) return ret;
const auto loc =
std::upper_bound(attacking.begin(), attacking.end(), def_pos[i]);
if (loc == attacking.end()) return ret;
attacking.erase(loc);
}
for (int i = 0; i < attack_pos.size(); i++) {
const auto loc =
std::lower_bound(attacking.begin(), attacking.end(), attack_pos[i]);
if (loc == attacking.end()) return ret;
ret += (*loc - attack_pos[i]);
attacking.erase(loc);
}
for (int i = 0; i < attacking.size(); i++) ret += attacking[i];
return ret;
}
int main(int argc, const char** argv) {
std::ios_base::sync_with_stdio(false);
int n, m;
std::cin >> n >> m;
std::vector<int> attack_pos, def_pos;
for (int i = 0; i < n; i++) {
std::string type;
int strength;
std::cin >> type >> strength;
if (type == "ATK")
attack_pos.push_back(strength);
else
def_pos.push_back(strength);
}
std::vector<int> attacking(m);
for (int i = 0; i < m; i++) std::cin >> attacking[i];
std::vector<int> original = attacking;
std::sort(attacking.begin(), attacking.end(), std::greater<int>());
std::sort(attack_pos.begin(), attack_pos.end());
std::sort(def_pos.begin(), def_pos.end());
long long damage = 0;
const int lim = std::min(attacking.size(), attack_pos.size());
for (int i = 0; i < lim; i++) {
if (attacking[i] >= attack_pos[i])
damage += attacking[i] - attack_pos[i];
else
goto finish;
}
attacking.erase(attacking.begin(), attacking.begin() + lim);
std::reverse(attacking.begin(), attacking.end());
for (int i = 0; i < def_pos.size(); i++) {
if (attacking.size() == 0) goto finish;
const auto loc =
std::upper_bound(attacking.begin(), attacking.end(), def_pos[i]);
if (loc == attacking.end()) goto finish;
attacking.erase(loc);
}
for (int i = 0; i < attacking.size(); i++) damage += attacking[i];
finish:
std::cout << std::max(damage, other_try(original, attack_pos, def_pos))
<< '\n';
return EXIT_SUCCESS;
}
| 2 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<stack>
#include<cstdio>
#include<sstream>
#include<iomanip>
#include<assert.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef ll Def;
typedef pair<Def,Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def,pii> pip;
typedef vector<pip>vip;
//#define mt make_tuple
//typedef tuple<double,int,double> tp;
//typedef vector<tp> vt;
const double PI=acos(-1);
const double EPS=1e-7;
const int inf=1e9;
const ll INF=2e18;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
vp po;
vvi _T;
int n,m,w,t;
void dfs(int now,int pre){
rep(j,n)if((now&1<<j)==0){
int to=now|1<<j;
int q;
if(pre+1)q=-abs(po[pre].first)-abs(po[pre].second)+abs(po[pre].first-po[j].first)+abs(po[pre].second-po[j].second)+abs(po[j].first)+abs(po[j].second);
else q=2*(abs(po[j].first)+abs(po[j].second));
_T[j][to]=min(_T[j][to],(pre+1?_T[pre][now]:0)+q);
dfs(to,j);
}
}
int main(){
cin>>n>>m>>w>>t;
map<string,int>ma;//name -> weight value
vp syo(m);
rep(i,m){
string a;
int b,c;
cin>>a>>b>>c;
ma[a]=i;
syo[i]=pii(b,c);
}
vvp in(n);
po=vp(n);
rep(i,n){
int l;
cin>>l>>po[i].first>>po[i].second;
vp q(l);
rep(j,l){
string s;int b;
cin>>s>>b;
q[j]=pii(ma[s],b);
}
in[i]=q;
}
int N=1<<n;
vi W(N);
_T=vvi(n,vi(N,inf));
loop(i,1,N){
vi ne(m,inf);
rep(j,n)if(i&1<<j){
rep(k,in[j].size()){
ne[in[j][k].first]=min(ne[in[j][k].first],in[j][k].second);
}
}
rep(j,m)if(ne[j]!=inf)ne[j]=max(0ll,syo[j].second-ne[j]);
else ne[j]=0;
vi dp(w+1);
// rep(j,m)cout<<" "<<ne[j];cout<<endl;
rep(j,m)rep(k,w+1)if(k+syo[j].first<=w)dp[k+syo[j].first]=max(dp[k+syo[j].first],dp[k]+ne[j]);
// int ma=0;
// rep(j,w+1)ma=max(ma,dp[j]);
W[i]=dp[w];
}
dfs(0,-1);
vi T(N,inf);
rep(i,N){
ll mi=inf;
rep(j,n)mi=min(mi,_T[j][i]);
T[i]=mi;
}
// rep(i,N)cout<<W[i]<<" "<<T[i]<<endl;
vi dp(t+1);
loop(i,1,N)rep(j,t+1)if(j+T[i]<=t)dp[j+T[i]]=max(dp[j+T[i]],dp[j]+W[i]);
cout<<dp[t]<<endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long K;
cin>>K;
queue<long long> q;
for(int i=1;i<=9;i++)
{
q.push(i);
}
while(!q.empty())
{
long long x=q.front();
q.pop();
K--;
if (K==0)
{
cout<<x<<endl;
break;
}
for(int y=(x%10)-1;y<=(x%10)+1;y++) {
if (y<0 || y>=10)
{
continue;
}
q.push(x*10+(long long)y);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define MAX_N (100010)
using namespace std;
typedef long long Int;
int par[MAX_N];
Int w[MAX_N];
Int abso[MAX_N];
void init(int N)
{
for (int i = 0; i < N; i++) par[i] = i;
}
int goup(int x)
{
if (x == par[x]) return (x);
else {
int p = goup(par[x]);
w[x] += w[par[x]];
return (par[x] = p);
}
}
Int weight(int x)
{
goup(x);
return (w[x] + abso[x]);
}
void merge(int x, int y, Int z)
{
z += weight(x) - weight(y);
x = goup(x); y = goup(y);
if (x == y) return;
par[y] = x;
w[y] = z;
}
bool same(int x, int y)
{
return (goup(x) == goup(y));
}
int main()
{
int N, Q;
scanf("%d %d", &N, &Q);
init(N);
for (int i = 0; i < Q; i++){
char s[16];
scanf("%s", s);
if (s[0] == 'C'){
int A, B;
scanf("%d %d", &A, &B);
A--; B--;
if (!same(A, B)) printf("WARNING\n");
else {
printf("%lld\n", weight(B) - weight(A));
}
}
else {
int A, B, C;
scanf("%d %d %d", &A, &B, &C);
A--; B--;
abso[A] += C; abso[B] += C;
merge(A, B, C);
}
}
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2 * 1e5;
const long long mod = 1e9 + 7;
long long len, fact[MAXN + 5], inv[MAXN + 5];
long long pref[MAXN + 5], suf[MAXN + 5];
string in;
long long nck(long long n, long long k) {
long long tmp1 = fact[n];
long long tmp2 = inv[k];
long long tmp = inv[n - k];
return ((tmp2 * tmp) % mod * tmp1) % mod;
}
long long pw(long long a, long long b) {
if (b == 0)
return 1;
else {
long long tmp = pw(a, b / 2);
if (b % 2)
return ((tmp * tmp) % mod * a) % mod;
else
return (tmp * tmp) % mod;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> in;
len = in.length();
fact[0] = 1;
inv[0] = 1;
for (long long i = 1; i <= len; i++) {
fact[i] = (fact[i - 1] * i) % mod;
inv[i] = pw(fact[i], mod - 2) % mod;
}
for (long long i = 0; i < len; i++) {
if (i > 0) pref[i] = pref[i - 1];
if (in[i] == '(') pref[i]++;
}
for (long long i = len - 1; i >= 0; i--) {
suf[i] = suf[i + 1];
if (in[i] == ')') suf[i]++;
}
long long ans = 0;
for (long long i = 0; i < len; i++) {
long long l = pref[i], r = suf[i];
if (in[i] != '(' || r == 0) continue;
long long add = nck(l + r - 1, l);
ans = (ans + add) % mod;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main(void) {
int t;
scanf("%d", &t);
while (t--) {
char a[101], b[101], c[101];
scanf("%s", a);
scanf("%s", b);
scanf("%s", c);
int s = strlen(a);
int i = 0;
for (i = 0; i < s; i++) {
if (a[i] == c[i]) {
continue;
} else if (b[i] == c[i]) {
continue;
} else {
printf("NO\n", i);
break;
}
}
if (i > s - 1) {
printf("YES\n");
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100, LOG = 18, A = 10, inF = 2e9;
int n, m, q, u, v, a, LCA, h[N], upper[N][LOG];
vector<int> nei[N], in[N], vec[N][LOG];
void dfs(int v) {
vector<int> help;
for (int i = 1; i < LOG; i++) {
upper[v][i] = upper[upper[v][i - 1]][i - 1];
help.clear();
for (int num : vec[v][i - 1]) help.push_back(num);
for (int num : vec[upper[v][i - 1]][i - 1]) help.push_back(num);
sort(help.begin(), help.end());
help.push_back(inF);
for (int j = 0; j < help.size() - 1 && vec[v][i].size() <= A; j++)
if (help[j] != help[j + 1]) vec[v][i].push_back(help[j]);
}
for (int u : nei[v])
if (u != upper[v][0]) {
h[u] = h[v] + 1;
upper[u][0] = v;
help.clear();
for (int num : in[v]) help.push_back(num);
for (int num : in[u]) help.push_back(num);
sort(help.begin(), help.end());
help.push_back(inF);
for (int j = 0; j < help.size() - 1 && vec[u][0].size() <= A; j++)
if (help[j] != help[j + 1]) vec[u][0].push_back(help[j]);
dfs(u);
}
}
int lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
for (int i = LOG - 1; i >= 0; i--)
if (h[u] - (1LL << i) >= h[v]) u = upper[u][i];
if (u == v) return u;
for (int i = LOG - 1; i >= 0; i--)
if (upper[u][i] != upper[v][i]) {
u = upper[u][i];
v = upper[v][i];
}
return upper[u][0];
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
nei[--u].push_back(--v);
nei[v].push_back(u);
}
for (int i = 0; i < m; i++) {
cin >> u;
if (in[--u].size() < A) in[u].push_back(i + 1);
}
dfs(0);
set<int> ST;
while (q--) {
ST.clear();
cin >> u >> v >> a;
LCA = lca(--u, --v);
for (int num : in[v]) {
ST.insert(num);
if (ST.size() > a) ST.erase(--ST.end());
}
for (int num : in[u]) {
ST.insert(num);
if (ST.size() > a) ST.erase(--ST.end());
}
for (int i = LOG - 1; i >= 0; i--)
if (h[u] - (1LL << i) >= h[LCA]) {
for (int num : vec[u][i]) {
ST.insert(num);
if (ST.size() > a) ST.erase(--ST.end());
}
u = upper[u][i];
}
for (int i = LOG - 1; i >= 0; i--)
if (h[v] - (1LL << i) >= h[LCA]) {
for (int num : vec[v][i]) {
ST.insert(num);
if (ST.size() > a) ST.erase(--ST.end());
}
v = upper[v][i];
}
a = min(a, (int)ST.size());
cout << a << ' ';
while (ST.size() > a) ST.erase(--ST.end());
for (int num : ST) cout << num << ' ';
cout << '\n';
}
return 0;
}
| 5 |
#include<iostream>
#include<string>
#include<queue>
#include<algorithm>
#include<map>
#include<set>
#include<vector>
#include<math.h>
using namespace std;
#define INF 1000000007
#define LINF (1LL << 62)
typedef long long i64;
typedef pair<i64,i64> P;
int h, w, k, ans[303][303];
string s[303];
int main(){
cin >> h >>w >> k;
for(int i = 0; i < h; i++){
cin >> s[i];
}
int now = 1;
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
if(s[i][j] == '#'){
for(int jj = 0; jj < w; jj++){
if(ans[i][jj]) continue;
if(j != jj && s[i][jj] == '#') break;
ans[i][jj] = now;
}
now++;
}
}
}
for(int i = 1; i < h; i++){
if(ans[i][0]) continue;
for(int j = 0; j < w; j++){
ans[i][j] = ans[i-1][j];
}
}
for(int i = h-1; i >= 0; i--){
if(ans[i][0]) continue;
for(int j = 0; j < w; j++){
ans[i][j] = ans[i+1][j];
}
}
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
printf("%3d ", ans[i][j]);
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int power[15] = {1, 2, 4, 8, 16, 32, 64, 128,
256, 512, 1024, 2048, 4096, 8192, 16384};
int main() {
int nizNext[2000];
int nizVals[2000];
int nizValsTemp[2000];
int nizDepth[2000];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> nizVals[i];
}
for (int i = n - 2; i >= 0; i--) {
for (int j = 14; j >= 0; j--) {
if (i + power[j] < n) {
nizNext[i] = i + power[j];
break;
}
}
}
for (int i = 1; i < n; i++) {
int res = 0;
for (int k = 0; k < n; k++) nizValsTemp[k] = nizVals[k];
int count = 0;
for (int j = 0; j < i; j++) {
count++;
res += nizValsTemp[j];
nizValsTemp[nizNext[j]] += nizValsTemp[j];
}
printf("%d\n", res);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 500010;
struct DSU {
int par[MAXN];
int sz[MAXN];
DSU() {
for (int i = 1; i < MAXN; i++) par[i] = i;
for (int i = 1; i < MAXN; i++) sz[i] = 1;
}
int get(int x) {
if (par[x] == x) return x;
return par[x] = get(par[x]);
}
void join(int x, int y) {
x = get(x);
y = get(y);
if (x == y) return;
if (sz[x] > sz[y]) swap(x, y);
par[x] = y;
sz[y] += sz[x];
}
} dsu;
int n, m, k, u, v, x, y, t, a, b, root = 1;
int mark[MAXN];
vector<int> G[MAXN];
vector<int> out[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
while (m--) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 2; i <= n; i++)
if (G[i].size() < G[root].size()) root = i;
for (int i = 0; i <= n; i++) mark[i] = 2;
for (int i : G[root]) mark[i] = 1;
for (int i = 1; i <= n; i++)
if (mark[i] == 2) dsu.join(root, i);
for (int i : G[root]) mark[i] = 0;
for (int i : G[root]) {
int tmp = 0;
for (int j : G[i]) {
if (mark[j] == 2)
tmp++;
else
mark[j] = 1;
}
if (tmp < n - G[root].size()) dsu.join(root, i);
for (int j : G[root])
if (!mark[j]) dsu.join(i, j);
for (int j : G[i])
if (mark[j] != 2) mark[j] = 0;
}
for (int i = 1; i <= n; i++) {
if (dsu.get(i) == i) t++;
out[dsu.get(i)].push_back(i);
}
cout << t << '\n';
for (int i = 1; i <= n; i++) {
if (out[i].empty()) continue;
cout << out[i].size() << ' ';
for (int j : out[i]) cout << j << ' ';
cout << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, i;
cin >> n;
int a[n];
int b[10004];
for (i = 0; i < 10004; i++) b[i] = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
b[a[i]]++;
}
long long int x = *max_element(a, a + n);
for (i = 1; i <= sqrt(x); i++) {
if (x % i == 0) {
if (i == x / i) {
b[i]--;
} else {
b[i]--;
b[x / i]--;
}
}
}
long long int y = -1;
for (i = 0; i < n; i++) {
if (b[a[i]] != 0) {
if (a[i] > y) y = a[i];
}
}
cout << x << " " << y << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool in1, in2, in3, in4;
int main() {
cin >> in1 >> in2 >> in3 >> in4;
printf("%d\n",
int(((in1 ^ in2) & (in3 | in4)) ^ ((in2 & in3) | (in1 ^ in4))));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[4][4];
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) cin >> a[i][j];
if (a[0][3] == 1 &&
(a[0][0] || a[0][1] || a[0][2] || a[1][0] || a[2][1] || a[3][2]))
cout << "YES";
else if (a[1][3] == 1 &&
(a[1][0] || a[1][1] || a[1][2] || a[2][0] || a[3][1] || a[0][2]))
cout << "YES";
else if (a[2][3] == 1 &&
(a[2][0] || a[2][1] || a[2][2] || a[3][0] || a[0][1] || a[1][2]))
cout << "YES";
else if (a[3][3] == 1 &&
(a[3][0] || a[3][1] || a[3][2] || a[0][0] || a[1][1] || a[2][2]))
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> adj[N];
int sum1[N], now1, wow, cac1, level[N];
bool used[N];
void dfs(int x, int p) {
if (level[x] == now1) {
sum1[x]++;
}
for (int i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != p) {
level[adj[x][i]] = level[x] + 1;
dfs(adj[x][i], x);
sum1[x] += sum1[adj[x][i]];
}
}
}
void dfs1(int x, int p) {
sum1[x] = 0;
if (level[x] == now1) {
sum1[x]++;
}
for (int i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != p && !used[adj[x][i]]) {
dfs1(adj[x][i], x);
sum1[x] += sum1[adj[x][i]];
}
}
}
int findcen(int x, int p, int sz) {
for (int i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != p && sum1[adj[x][i]] > sz / 2 && !used[adj[x][i]]) {
return findcen(adj[x][i], x, sz);
}
}
return x;
}
void findans(int x, int p, int sz) {
if (sz == 1) {
cac1 = x;
return;
}
dfs1(x, x);
int mid = findcen(x, x, sz);
used[mid] = true;
cout << "d " << mid << endl;
fflush(stdout);
cin >> wow;
if (wow + level[mid] == now1) {
if (wow == 0) {
cout << "! " << mid << endl;
fflush(stdout);
exit(0);
}
cout << "s " << mid << endl;
fflush(stdout);
cin >> wow;
findans(wow, wow, sum1[wow]);
} else {
findans(x, x, sz - sum1[mid]);
}
}
int dfs2(int x, int p) {
if (level[x] == now1) {
return x;
}
int i, j;
for (i = 0; i < adj[x].size(); i++) {
if (adj[x][i] != p && !used[adj[x][i]]) {
j = dfs2(adj[x][i], x);
if (j != -1) {
return j;
}
}
}
return -1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, i, j, k;
cin >> n;
for (i = 1; i < n; i++) {
cin >> j >> k;
adj[j].push_back(k);
adj[k].push_back(j);
}
cout << "d 1" << endl;
fflush(stdout);
cin >> now1;
dfs(1, 1);
findans(1, 1, sum1[1]);
i = dfs2(cac1, cac1);
cout << "! " << i << endl;
fflush(stdout);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
if (k > 1) {
cout << "Yes" << endl;
return 0;
}
vector<int> v;
int prev;
cin >> prev;
v.push_back(prev);
int index;
if (prev == 0) {
index = 0;
}
for (int i = 1; i < n; i++) {
int next;
cin >> next;
if (next == 0) {
index = i;
} else if (next < prev) {
cout << "Yes" << endl;
return 0;
} else {
prev = next;
}
v.push_back(next);
}
cin >> k;
if (index == 0 && k < v[index + 1]) {
cout << "No" << endl;
return 0;
}
if (index == n - 1 && k > v[index - 1]) {
cout << "No" << endl;
return 0;
}
if (index > 0 && index < n - 1 && k > v[index - 1] && k < v[index + 1]) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
}
| 1 |
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
ll gcd(ll a,ll b){
for(;a;swap(a,b)) b%=a;
return b;
}
ll lcm(ll a,ll b){
return a*b/gcd(a,b);
}
int main(){
for(int n;scanf("%d",&n),n;){
int d[10],v[10];
for(int i=0;i<n;i++){
scanf("%d%d",d+i,v+i);
int g=gcd(d[i],v[i]);
d[i]/=g,v[i]/=g;
}
ll deno=d[0];
for(int i=1;i<n;i++) deno=lcm(deno,d[i]);
ll nume[10];
for(int i=0;i<n;i++) nume[i]=v[i]*deno/d[i];
ll g=nume[0];
for(int i=1;i<n;i++) g=gcd(g,nume[i]);
for(int i=0;i<n;i++) printf("%d\n",nume[i]/g);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long ans = 0, cnt = 0, n, len, a, b, i, k, arr[100005];
string s;
cin >> n >> k;
for (int i = 0; i < (n); i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (i = n - 1; i >= 0; i--) {
ans += arr[i] / (2 * k);
arr[i] = arr[i] % (2 * k);
}
for (i = 0; i < n; i++) {
cnt += arr[i] / k;
arr[i] = arr[i] % k;
}
for (int i = 0; i < (n); i++) {
if (arr[i]) cnt++;
}
cout << ans + (cnt + 1) / 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 10;
const double eps = 1e-9;
const int inf = 1e9;
int a[mx];
char vowel[5] = {'a', 'e', 'i', 'o', 'u'};
bool IsPrimeSlow(long long x) {
if (x <= 1) return false;
if (x <= 3) return true;
if (!(x % 2) | !(x % 3)) return false;
long long second = (long long)(sqrt((double)(x)) + eps);
for (long long i = 5; i <= second; i += 6)
if (!(x % i) || !(x % (i + 2))) return false;
return true;
}
int main() {
int n;
scanf("%d", &n);
if (IsPrimeSlow(n) || n < 25) {
return printf("-1"), 0;
}
int x = 1, y = n;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0 && i > 4) {
x = i;
y = n / i;
break;
}
}
if (x < 5 || y < 5 || x == n || y == n) {
return printf("-1"), 0;
}
int pos = 0, cnt = 0;
for (int i = 1; i <= x; i++) {
for (int j = 1; j <= y; j++) {
printf("%c", vowel[(pos + cnt) % 5]);
pos++;
}
cnt++;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int o = 0; o < q; o++) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
double s = 0;
for (int i = 0; i < n; i++) {
s += a[i];
}
s /= n;
int ans = ceil(s);
cout << ans << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int n;ll k;
int a[200010],head[200010],nxt[200010],ne[200010],cz[200010],t[200010];
int sta[200010],top;bool b[200010];
int calc(int pl){
for(int i=pl;i<=n;i++){
if(!b[a[i]])sta[++top]=a[i],b[a[i]]=1;
else {
b[a[i]]=0;
while(sta[top]!=a[i])b[sta[top]]=0,top--;
top--;
}
}
for(int i=1;i<=top;i++)cout<<sta[i]<<' ';exit(0);
}
int main(){
cin>>n>>k;
if(n==1&((k+1)&1))return 0;
for(int i=1;i<=n;i++)cin>>a[i];
if(k==1)calc(1);
for(int i=n;i>=1;i--){
nxt[i]=head[a[i]];
head[a[i]]=i;
}
for(int i=1;i<=n;i++)if(!nxt[i])nxt[i]=head[a[i]];
for(int i=n;i>=1;i--)if(nxt[i]<=i)ne[i]=nxt[i];
else ne[i]=ne[nxt[i]+1];
for(int i=1;i<=n;i++)ne[i]=ne[i]+1;ne[n+1]=1;
cz[1]=1;t[1]=1;
for(int i=2;i<=k;i++){
cz[i]=ne[cz[i-1]];
if(i==k)calc(cz[i]);
if(t[cz[i]]){
//xunhuanjie:
int L=t[cz[i]],R=i-1;
k=(k-L+1)%(R-L+1);
if(k==0)k=R-L+1;
calc(cz[k]);
}
t[cz[i]]=i;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long x) {
long long ans = 1;
for (int i = 0; i < x; ++i) ans *= a;
return ans;
}
int main() {
int n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
long long sum = 0;
for (int i = 0; i < n; ++i) sum += v[i];
long long ans = sum - n;
sort(v.begin(), v.end());
if (n < 50) {
int m = pow(10, (double)16 / n);
for (int pair = 2; pair <= m; ++pair) {
long long diff = 0;
long long powe = 1;
for (int i = 0; i < n; ++i) {
diff += abs(v[i] - powe);
powe *= pair;
}
if (diff < ans) ans = diff;
}
}
cout << ans << endl;
;
return 0;
}
| 2 |
#include <iostream>
#include <deque>
#include <vector>
using namespace std;
int n,m;
bool used[100005];
vector<int> g[100005];
deque<int> dq;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cin>>n>>m;
for(int i=0;i<m;i++){
int u,v;
cin>>u>>v;
g[u].push_back(v);
g[v].push_back(u);
}
dq.push_back(1);
used[1]=true;
while(true){
int u=dq.front();
for(int i=0;i<g[u].size();i++){
int v=g[u][i];
if(!used[v]){
dq.push_front(v);
used[v]=true;
break;
}
}
if(u!=dq.front())continue;
u=dq.back();
for(int i=0;i<g[u].size();i++){
int v=g[u][i];
if(!used[v]){
dq.push_back(v);
used[v]=true;
break;
}
}
if(u!=dq.back())continue;
break;
}
cout<<dq.size()<<endl;
while(!dq.empty()){
cout<<dq.front()<<' ';
dq.pop_front();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
char c;
while ((c = getchar()) < '0' || c > '9')
;
return c - '0';
}
pair<pair<long long, long long>, long long> b[200005];
pair<long long, long long> a[200005];
long long bridge[200005];
map<long long, long long> mp, mp1;
vector<long long> adj[200005];
long long ans[200005];
set<long long> st;
set<long long>::iterator it;
bool comp(pair<pair<long long, long long>, long long> p1,
pair<pair<long long, long long>, long long> p2) {
if (p1.first.second < p2.first.second) {
return true;
} else if (p1.first.second > p2.first.second) {
return false;
}
return p1.first.first < p2.first.first;
}
int main() {
long long n, m, i, p;
scanf("%lld %lld", &n, &m);
for (i = 0; i < n; i++) {
scanf("%lld %lld", &a[i].first, &a[i].second);
}
for (i = 1; i < n; i++) {
b[i - 1].first.first = a[i].first - a[i - 1].second;
b[i - 1].first.second = a[i].second - a[i - 1].first;
b[i - 1].second = i - 1;
}
long long curr = 0;
for (i = 0; i < m; i++) {
scanf("%lld", &p);
st.insert(p);
if (mp[p] == 0) {
mp1[p] = curr;
curr++;
}
mp[p]++;
adj[mp1[p]].push_back(i + 1);
}
sort(b, b + n - 1, comp);
for (i = 0; i < n - 1; i++) {
if (st.empty()) {
printf("No");
return 0;
}
it = st.lower_bound(b[i].first.first);
if (it == st.end()) {
printf("No");
return 0;
}
p = (*it);
if (p > b[i].first.second) {
printf("No");
return 0;
}
mp[p]--;
ans[b[i].second] = adj[mp1[p]][mp[p]];
if (mp[p] == 0) {
st.erase(it);
}
}
printf("Yes\n");
for (i = 0; i < n - 1; i++) {
printf("%lld ", ans[i]);
}
return 0;
}
| 2 |
#include<queue>
#include<cstdio>
#include<vector>
#include<complex>
#define pb push_back
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef complex<double> Point;
const double EPS=1e-9;
class Line:public vector<Point>{
public:
Line(){}
Line(const Point &a,const Point &b){ pb(a), pb(b); }
};
class Segment:public Line{
public:
Segment(){}
Segment(const Point &a,const Point &b):Line(a,b){}
};
double dot(const Point &a,const Point &b){
return real(a)*real(b)+imag(a)*imag(b);
}
double cross(const Point &a,const Point &b){
return real(a)*imag(b)-imag(a)*real(b);
}
enum {CCW=1,CW=-1,ON=0};
int ccw(const Point &a,Point b,Point c){
b-=a,c-=a;
double rotdir=cross(b,c);
if(rotdir>EPS) return CCW;
if(rotdir<-EPS) return CW;
return ON;
}
bool cover(const Segment &s,const Point &p){
return dot(s[0]-p,s[1]-p)<EPS;
}
bool intersect(const Segment &s,const Segment &t){
// S and T are on the same line
if(abs(cross(s[1]-s[0],t[1]-t[0]))<EPS && abs(cross(s[1]-s[0],t[0]-s[0]))<EPS){
return cover(s,t[0]) || cover(s,t[1]) || cover(t,s[0]) || cover(t,s[1]);
}
return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1])<=0
&& ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1])<=0;
}
vvi toConnectedComponents(const vvi &adj){
int n=adj.size();
vvi res;
vb visited(n);
rep(i,n)if(!visited[i]){
vi comp;
queue<int> qu; qu.push(i); visited[i]=true;
while(!qu.empty()){
int u=qu.front(); qu.pop();
comp.pb(u);
rep(j,adj[u].size()){
int v=adj[u][j];
if(!visited[v]){ qu.push(v); visited[v]=true; }
}
}
res.pb(comp);
}
return res;
}
int main(){
for(int n;scanf("%d",&n),n;){
Segment s[1000];
rep(i,n){
int x1,y1,x2,y2;
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
s[i]=Segment(Point(x1,y1),Point(x2,y2));
}
vvi adj(n);
rep(i,n)rep(j,i){
if(intersect(s[i],s[j])){
adj[i].pb(j);
adj[j].pb(i);
}
}
int hist[10]={};
vvi comps=toConnectedComponents(adj);
rep(i,comps.size()){
vi comp=comps[i];
int num=comp.size();
int degsum=0;
rep(j,num) degsum+=adj[comp[j]].size();
if(num==1) hist[1]++;
else if(num==3){
int mid;
rep(j,3) if(adj[comp[j]].size()==2) mid=comp[j];
int cnt=0;
rep(j,3)if(comp[j]!=mid){
if(s[mid][0]==s[comp[j]][0] || s[mid][0]==s[comp[j]][1]
|| s[mid][1]==s[comp[j]][0] || s[mid][1]==s[comp[j]][1]) cnt++;
}
if(cnt==1) hist[4]++;
else hist[7]++;
}
else if(num==4){
if(degsum==6) hist[3]++;
else{
int cnt=0;
rep(j,4){
int u=comp[j];
rep(k,2){
int v=adj[u][k];
if(s[u][0]==s[v][0] || s[u][0]==s[v][1]
|| s[u][1]==s[v][0] || s[u][1]==s[v][1]) cnt++;
}
}
if(cnt==8) hist[0]++;
else hist[9]++;
}
}
else{ // num==5
if(degsum==10) hist[6]++;
else if(degsum==12) hist[8]++;
else{
Segment e1,e2;
rep(j,5){
if(adj[comp[j]].size()==1){
e1=s[comp[j]];
e2=s[adj[comp[j]][0]];
break;
}
}
if(e1[0]==e2[0]) swap(e1[0],e1[1]);
else if(e1[0]==e2[1]) swap(e1[0],e1[1]), swap(e2[0],e2[1]);
else if(e1[1]==e2[1]) swap(e2[0],e2[1]);
if(cross(e1[1]-e1[0],e2[1]-e2[0])<-1+EPS) hist[2]++;
else hist[5]++;
}
}
}
rep(i,10) printf("%s%d",i?" ":"",hist[i]);
putchar('\n');
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int p = 0, i = 0;
scanf("%d\n", &p);
for (i = 0; i < p; i++) {
int a = 0, b = 0, c = 0, e = 0;
char d[100];
scanf("%d\n", &a);
gets(d);
if (a >= 11) {
for (b = 0; b < a; b++) {
if (d[b] == '8') {
c = a - b;
break;
}
}
}
if (c >= 11)
printf("YES\n");
else
printf("NO\n");
}
}
| 1 |
#include <bits/stdc++.h>
char _;
using namespace std;
int N, C, D;
pair<int, int> A[400000];
long long Z, ZO, ZOZ, O, OZ, OZO;
inline bool cmp(const pair<int, int>& a, const pair<int, int>& b) {
if ((b.second < 0) ^ (a.second < 0))
return 1LL * a.first * b.second > 1LL * b.first * a.second;
return 1LL * a.first * b.second < 1LL * b.first * a.second;
}
inline bool eq(const pair<int, int>& a, const pair<int, int>& b) {
return 1LL * a.first * b.second == 1LL * b.first * a.second;
}
int main() {
do {
while ((N = getchar()) < '0')
;
for (N -= '0'; '0' <= (_ = getchar()); N = (N << 3) + (N << 1) + _ - '0')
;
} while (0);
do {
while ((C = getchar()) < '0')
;
for (C -= '0'; '0' <= (_ = getchar()); C = (C << 3) + (C << 1) + _ - '0')
;
} while (0);
do {
while ((D = getchar()) < '0')
;
for (D -= '0'; '0' <= (_ = getchar()); D = (D << 3) + (D << 1) + _ - '0')
;
} while (0);
for (int i = 0; i < N; i++) {
do {
while ((A[i].first = getchar()) < '0')
;
for (A[i].first -= '0'; '0' <= (_ = getchar());
A[i].first = (A[i].first << 3) + (A[i].first << 1) + _ - '0')
;
} while (0);
do {
while ((A[i].second = getchar()) < '0')
;
for (A[i].second -= '0'; '0' <= (_ = getchar());
A[i].second = (A[i].second << 3) + (A[i].second << 1) + _ - '0')
;
} while (0);
A[i].first -= C, A[i].second -= D;
}
sort(A, A + N, cmp);
for (int i = 0, j; i < N; i = j) {
long long NZ = Z, NZO = ZO, NZOZ = ZOZ, NO = O, NOZ = OZ, NOZO = OZO;
for (j = i; j < N && eq(A[i], A[j]); j++) {
if (A[j].second < 0) {
NOZO += OZ;
NZO += Z;
NO++;
} else {
NZOZ += ZO;
NOZ += O;
NZ++;
}
}
Z = NZ, ZO = NZO, ZOZ = NZOZ, O = NO, OZ = NOZ, OZO = NOZO;
}
int L = 0, R = 0, D = 0;
for (int i = 0; i < N; i++)
if (A[i].second == 0) {
if (A[i].first < 0)
L++;
else
R++;
}
for (int i = 0; i < N; i++)
if (A[i].second < 0) D++;
printf("%lld\n", OZO + ZOZ - 1LL * L * R * D);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const long long int INFLL = 1e18 + 10;
const long double EPS = 1e-8;
const long double EPSLD = 1e-14;
const long long int MOD = 1e9 + 7;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
const int MAX_N = 100010;
int n, m;
int a[MAX_N];
int b[MAX_N];
int as, bs;
int s[MAX_N];
set<int> ss;
int main() {
scanf("%d %d\n", &n, &m);
for (int i = (0); i < (int)(n); i++) {
char c;
int x;
scanf("%c%d\n", &c, &x);
x--;
if (c == '+') {
as++;
a[x]++;
s[i] = x;
} else if (c == '-') {
bs++;
b[x]++;
s[i] = x + INF;
}
}
for (int i = (0); i < (int)(n); i++) {
if (a[i] + (bs - b[i]) == m) ss.insert(i);
}
for (int i = (0); i < (int)(n); i++) {
if (s[i] >= INF) {
int r = s[i] - INF;
if (ss.find(r) == ss.end()) {
puts("Truth");
} else {
if (ss.size() == 1)
puts("Lie");
else
puts("Not defined");
}
} else {
if (ss.find(s[i]) == ss.end()) {
puts("Lie");
} else {
if (ss.size() == 1)
puts("Truth");
else
puts("Not defined");
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x0, y0, x, y;
cin >> n >> x0 >> y0;
unordered_set<double> us;
while (n--) {
cin >> x >> y;
if (x == x0) {
us.insert(1000000000);
continue;
}
double d = (y - y0) / (double)(x - x0);
us.insert(d);
}
cout << us.size() << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int from[42], to[42];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", from + i, to + i);
}
double res = 0;
for (int ans = 1; ans <= 10007; ans++) {
for (int t = 0; t < (1 << n); t++) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (t & (1 << i)) {
cnt++;
}
}
if (cnt < 2) {
continue;
}
double prob = 1.0;
for (int i = 0; i < n; i++) {
int a = from[i];
int b = to[i];
if (t & (1 << i)) {
if (a < ans) a = ans;
} else {
if (b > ans - 1) b = ans - 1;
}
if (a > b) {
prob = 0.0;
break;
}
int cur = b - a + 1;
prob *= 1.0 * cur / (to[i] - from[i] + 1);
}
res += prob;
}
}
printf("%.17f\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mxp2(long long a) {
long long ans = pow(2, 60);
while (a % ans) ans /= 2;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, q, u, temp;
cin >> n >> q;
string s;
while (q--) {
cin >> u >> s;
for (char c : s) {
temp = mxp2(u);
if (c == 'L')
u -= temp / 2;
else if (c == 'R')
u += temp / 2;
else if (u != (n + 1) / 2) {
if ((u + temp) % (4 * temp))
u += temp;
else
u -= temp;
}
}
cout << u << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
const int maxm = 1001100;
int par[maxm];
int ran[maxm];
int num[maxm];
bool check[maxm];
int n, m;
long long k;
int ned;
void init(int n) {
for (int i = 0; i < n; ++i) {
par[i] = i;
ran[i] = 0;
num[i] = 1;
check[i] = 0;
}
}
int change(int x, int y) { return x * m + y; }
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (ran[x] < ran[y]) {
par[x] = y;
num[y] += num[x];
} else {
par[y] = x;
num[x] += num[y];
if (ran[x] == ran[y]) ++ran[x];
}
}
bool same(int x, int y) { return find(x) == find(y); }
struct Poi {
int x;
int y;
int cost;
bool operator<(const Poi& p) const { return cost > p.cost; }
} poi[maxm];
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
bool work(int cc) {
int x = poi[cc].x;
int y = poi[cc].y;
long long cost = poi[cc].cost;
check[change(x, y)] = 1;
for (int i = 0; i < 4; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || (!check[change(nx, ny)]))
continue;
unite(change(x, y), change(nx, ny));
}
if (k % cost != 0) return false;
return ((long long)num[find(change(x, y))] >= (long long)(k / cost));
}
int ans[maxn][maxn];
int cnt;
void dfs(int x, int y, int cost) {
if (cnt == ned) return;
ans[x][y] = cost;
++cnt;
if (cnt == ned) return;
for (int i = 0; i < 4; ++i) {
if (cnt == ned) return;
int nx = x + dx[i];
int ny = y + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m || (!check[change(nx, ny)]) ||
(ans[nx][ny] > 0))
continue;
dfs(nx, ny, cost);
}
}
int main() {
scanf("%d%d%I64d", &n, &m, &k);
int M = n * m;
init(M);
int c;
int d;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
c = change(i, j);
scanf("%d", &d);
poi[c].x = i;
poi[c].y = j;
poi[c].cost = d;
}
}
sort(poi, poi + M);
for (int i = 0; i < M; ++i) {
if (work(i)) {
printf("YES\n");
ned = k / poi[i].cost;
memset(ans, 0, sizeof(ans));
dfs(poi[i].x, poi[i].y, poi[i].cost);
for (int i = 0; i < n; ++i) {
printf("%d", ans[i][0]);
for (int j = 1; j < m; ++j) printf(" %d", ans[i][j]);
printf("\n");
}
return 0;
}
}
printf("NO\n");
return 0;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 3e5 + 10;
void init(vector<pair<int, int>>& vp) {
vector<int> v;
for (auto& p : vp) v.push_back(p.second);
sort(v.begin(), v.end());
for (auto& p : vp) {
p.second = lower_bound(v.begin(), v.end(), p.second) - v.begin() + 1;
}
}
class BIT {
public:
long long a[N];
void add(int x, long long val) {
while (x < N) {
a[x] += val;
x += x & -x;
}
}
long long sum(int x) {
long long ret = 0;
while (x) {
ret += a[x];
x -= x & -x;
}
return ret;
}
} b1, b2;
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int>> vp(n);
for (auto& p : vp) scanf("%d", &p.first);
for (auto& p : vp) scanf("%d", &p.second);
init(vp);
long long ans = 0;
sort(vp.begin(), vp.end());
for (auto& p : vp) {
b1.add(p.second, 1);
b2.add(p.second, p.first);
ans += b1.sum(p.second) * p.first - b2.sum(p.second);
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0; (i)<(n); (i)++)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define ll long long
#define pii pair<int,int>
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
const int INF = 1001001001;
//int 2×10の9乗
//vector<vector<int>> a(n, vector<int>(m));
//rep(i,n) rep(j,m) cin >> a[i][j];
//cout << fixed << setprecision(10);
//int gcd(int x, int y){
//if(y==0) return x;
//return gcd(y, x%y);
//}
//sort小さい順(昇順)
//g++ code.cpp ./a.out
int main(){
while(true){
int n; cin >> n;
if(n==0) break;
map<char,int> m;
int s1=0, s2=0;
char u;
bool h=false;
rep(i,n){
char s; cin >> s; m[s]++;
if(m[s]>s1) {
if (u!=s) s2=s1;
u=s;
s1=m[s];}
else s2=max(s2,m[s]);
if(s1 > s2+n-i-1 && !h){
cout << u << " " << i+1 << endl;
h=true;
}
}
if (!h) cout << "TIE" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 1e5 + 10;
void solve() {
long long n, k;
cin >> n >> k;
vector<bool> vis(2 * n + 1, false);
vector<pair<long long, long long>> a;
for (long long i = 0; i < k; i++) {
long long x, y;
cin >> x >> y;
if (x > y) {
swap(x, y);
}
a.push_back({x, y});
vis[x] = true;
vis[y] = true;
}
vector<long long> unvis;
for (long long i = 1; i <= 2 * n; i++) {
if (!vis[i]) {
unvis.push_back(i);
}
}
for (long long i = 0, j = n - k; i < n - k; i++, j++) {
a.push_back({unvis[i], unvis[j]});
}
sort(a.begin(), a.end());
long long ans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
if (a[j].first < a[i].second && a[j].second > a[i].second) ans++;
}
}
cout << ans << "\n";
;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5), mod = int(1e9) + 7, block = 316;
int n, m, q;
vector<int> g[N], comp[N], heavy, di[N];
int root[N], cur, sz[N], d[N], dr[N], d1[N], d2[N];
bool used[N];
bool h[N];
long double ans[N], fans[N];
vector<pair<int, int> > qu[N];
void dfs(int v) {
used[v] = 1;
comp[cur].push_back(v);
sz[cur]++;
root[v] = cur;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used[to]) dfs(to);
}
}
void dfs1(int v, int p = -1) {
used[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
dfs1(to, v);
d1[v] = max(d1[v], d1[to] + 1);
}
}
void dfs2(int v, int p = -1) {
int mx1 = d2[v], mx2 = 0;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
if (d1[to] + 1 > mx1) {
mx2 = mx1;
mx1 = d1[to] + 1;
} else if (d1[to] + 1 > mx2) {
mx2 = d1[to] + 1;
}
}
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
if (mx1 == d1[to] + 1) {
d2[to] = mx2 + 1;
} else
d2[to] = mx1 + 1;
dfs2(to, v);
}
}
int a[N], b[N], an, bn;
long long pref[N];
void cons(int v) {
an = 0;
for (int i = 0; i < di[v].size(); i++) {
a[++an] = di[v][i];
}
for (int i = 1; i <= an; i++) {
pref[i] = pref[i - 1] + a[i];
}
}
long double get(int v, int curd) {
bn = 0;
long long sum = 0;
for (int i = 0; i < di[v].size(); i++) {
b[++bn] = di[v][i];
}
int j = an;
for (int i = 1; i <= bn; i++) {
while (j > 0 && b[i] + a[j] + 1 > curd) j--;
sum += 1ll * j * curd + 1ll * (an - j) * b[i] + pref[an] - pref[j] + an - j;
}
return (sum + 0.0) / (1ll * an * bn);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
cur = i;
dfs(i);
}
}
for (int i = 1; i <= n; i++) {
if (root[i] == i) {
if (sz[i] > block) {
heavy.push_back(i);
h[i] = 1;
}
}
}
memset(used, 0, sizeof(used));
for (int i = 1; i <= n; i++) {
if (!used[i]) {
dfs1(i);
dfs2(i);
int v = root[i];
for (int j = 0; j < comp[v].size(); j++) {
int u = comp[v][j];
dr[u] = max(d1[u], d2[u]);
di[v].push_back(dr[u]);
d[v] = max(d[v], dr[u]);
}
sort(di[v].begin(), di[v].end());
}
}
for (int i = 1, u, v; i <= q; i++) {
scanf("%d%d", &u, &v);
u = root[u];
v = root[v];
if (u == v) {
ans[i] = -1;
} else {
if (h[u]) {
qu[u].push_back(make_pair(v, i));
} else if (h[v]) {
qu[v].push_back(make_pair(u, i));
} else {
int curd = max(d[u], d[v]);
cons(u);
ans[i] = get(v, curd);
}
}
}
for (int i = 1; i <= n; i++) {
if (int(qu[i].size()) > 0) {
cons(i);
for (int j = 1; j <= n; j++)
if (root[j] == j) {
fans[j] = get(j, max(d[i], d[j]));
}
for (int j = 0; j < qu[i].size(); j++) {
ans[qu[i][j].second] = fans[qu[i][j].first];
}
}
}
for (int i = 1; i <= q; i++) {
printf("%.12lf\n", double(ans[i]));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 600005;
vector<long long int> gr[N];
long long int deg[N];
long long int nxt;
long long int d, k, n;
void dfs(long long int cur, long long int dep) {
if (dep <= 0) return;
for (long long int i = 0; i < k; i++) {
if (deg[cur] < k && nxt <= n) {
gr[cur].push_back(nxt);
gr[nxt++].push_back(cur);
long long int last = nxt - 1;
deg[cur]++;
deg[last]++;
dfs(last, dep - 1);
} else {
break;
}
}
}
void solve() {
long long int i, j, m, ans = 0, cnt = 0, sum = 0;
cin >> n >> d >> k;
for (i = 1; i <= d; i++) {
gr[i].push_back(i + 1);
gr[i + 1].push_back(i);
deg[i]++;
deg[i + 1]++;
}
nxt = d + 2;
for (i = 2; i <= d; i++) {
dfs(i, min(i - 1, (d + 1 - i)));
}
if (nxt <= n || nxt > n + 1) {
cout << "NO";
return;
}
for (i = 1; i <= n; i++) {
if (deg[i] > k) {
cout << "NO";
return;
}
}
cout << "YES\n";
for (i = 1; i <= n; i++) {
for (auto x : gr[i]) {
if (x < i) {
cout << x << " " << i << '\n';
}
}
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int pnt[100001][2];
long long int s1[100001];
long long int s2[100001];
int main() {
long long int n;
cin >> n;
for (long long int i = 1; i <= n; i++) cin >> pnt[i][0] >> pnt[i][1];
long long int sum = 0;
for (long long int i = 1; i <= n; i++) s1[i] = s1[i - 1] + pnt[i][0];
for (long long int i = 1; i <= n; i++)
s2[i] = s2[i - 1] + pnt[i][0] * pnt[i][0];
for (long long int i = 1; i <= n; i++) sum += (i - 1) * pnt[i][0] * pnt[i][0];
for (long long int i = 1; i <= n; i++) sum -= 2 * pnt[i][0] * s1[i - 1];
for (long long int i = 1; i <= n; i++) sum += s2[i - 1];
for (long long int i = 1; i <= n; i++) s1[i] = s1[i - 1] + pnt[i][1];
for (long long int i = 1; i <= n; i++)
s2[i] = s2[i - 1] + pnt[i][1] * pnt[i][1];
for (long long int i = 1; i <= n; i++) sum += (i - 1) * pnt[i][1] * pnt[i][1];
for (long long int i = 1; i <= n; i++) sum -= 2 * pnt[i][1] * s1[i - 1];
for (long long int i = 1; i <= n; i++) sum += s2[i - 1];
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
const long double PI = 3.141592653589793238462643383279502884197;
priority_queue<int, vector<int>, greater<int> > pq;
vector<int> v;
char visit[50];
int vec[50];
long long dp[50][50][50];
long long mp(long long a, long long b) {
long long ret = 1;
while (b) {
if (b % 2) ret = ret * a % MOD;
a = a * a % MOD;
b /= 2;
}
return ret;
}
int n, to, num, ou, od, m;
long long go(int me, int up, int dd) {
if (up + dd == m) return vec[num] + (visit[num] ? me : -me);
if (dp[me][up][dd] != -1) return dp[me][up][dd];
long long ret = 1, tmp = 0, tt = ((visit[num] ? me : -me) + vec[num]);
if (tt) {
ret *= go(me + 1, up + (visit[num] == 1), dd + (visit[num] == 0));
ret %= MOD;
ret *= tt * mp(to + up - dd, MOD - 2) % MOD;
ret %= MOD;
tmp = (tmp + ret) % MOD;
}
tt = (up - (visit[num] ? me : 0)) + (ou - (visit[num] ? vec[num] : 0));
if (tt) {
ret = 1;
ret *= go(me, up + 1, dd);
ret %= MOD;
ret *= tt * mp(to + up - dd, MOD - 2) % MOD;
ret %= MOD;
tmp = (tmp + ret) % MOD;
}
tt = (od - (visit[num] ? 0 : vec[num])) - (dd - (visit[num] ? 0 : me));
if (tt) {
ret = 1;
ret *= go(me, up, dd + 1);
ret %= MOD;
ret *= tt * mp(to + up - dd, MOD - 2) % MOD;
ret %= MOD;
tmp = (tmp + ret) % MOD;
}
return dp[me][up][dd] = tmp;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%hhd", &visit[i]);
for (int i = 0; i < n; i++) {
scanf("%d", &vec[i]);
to += vec[i];
if (visit[i] == 0)
od += vec[i];
else
ou += vec[i];
}
for (int i = 0; i < n; i++) {
memset(dp, -1, sizeof(dp));
num = i;
printf("%lld\n", go(0, 0, 0));
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool compare(const int& a, const int& b) { return a > b; }
int main() {
int a[101];
int i = 0;
int n, k;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, compare);
cout << a[k - 1] << endl;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
string itos(int n) {
stringstream ss;
ss << n;
string second = ss.str();
return second;
}
long long ppow(long long x, long long y, long long mod) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
y >>= 1;
x = x * x % mod;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long a, b, p;
cin >> a >> b >> p;
string second;
cin >> second;
int n = second.size();
vector<long long> dp(n + 1, 0);
int last = n;
if (second.back() == 'A')
second += 'B';
else
second += 'A';
for (int i = n - 2; i >= 0; --i) {
if (second[i] != second[i + 1]) {
last = i + 1;
}
if (second[last] == 'A') {
dp[i] = b + dp[last];
} else
dp[i] = a + dp[last];
}
int ans;
for (int i = 0; i < n; ++i) {
if (dp[i] <= p) {
ans = i;
break;
}
}
cout << ans + 1 << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 20;
long long sum;
int k, p, n, a[N + 1], i, b[N + 1], left_tree[N + 1], right_tree[N + 1];
vector<long long> leftv, rightv;
void update(int index, int value, int tree[]) {
while (index < N + 1) {
tree[index] += value;
index += (index & -index);
}
}
int read(int index, int tree[]) {
int sum = 0;
while (index > 0) {
sum += tree[index];
index -= (index & -index);
}
return sum;
}
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
for (i = 0; i < n; i++) {
a[i] = upper_bound(b, b + n, a[i]) - b;
}
for (i = 0; i < n; i++) {
update(a[i], 1, left_tree);
leftv.push_back(read(N, left_tree) - read(a[i], left_tree));
}
for (i = n - 1; i >= 0; i--) {
rightv.push_back(read(a[i], right_tree));
update(a[i], 1, right_tree);
}
reverse(rightv.begin(), rightv.end());
for (i = 0; i < n; i++) {
sum += rightv[i] * leftv[i];
}
cout << sum;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010, inf = 0x7fffffff;
int n, a[maxn], L[maxn][20], R[maxn][20];
inline int read() {
char ch = getchar();
int x = 0;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x;
}
struct node {
int minn[maxn << 2], maxx[maxn << 2];
void pushup(int o) {
minn[o] = min(minn[o * 2], minn[o * 2 + 1]);
maxx[o] = max(maxx[o * 2], maxx[o * 2 + 1]);
}
void build(int o, int l, int r, int id) {
if (l == r) {
minn[o] = L[l][id];
maxx[o] = R[l][id];
return;
}
int mid = (l + r) >> 1;
build(o * 2, l, mid, id);
build(o * 2 + 1, mid + 1, r, id);
pushup(o);
}
int query1(int o, int l, int r, int x, int y) {
if (x <= l && r <= y) return minn[o];
int mid = (l + r) >> 1, res = inf;
if (x <= mid) res = min(res, query1(o * 2, l, mid, x, y));
if (y > mid) res = min(res, query1(o * 2 + 1, mid + 1, r, x, y));
return res;
}
int query2(int o, int l, int r, int x, int y) {
if (x <= l && r <= y) return maxx[o];
int mid = (l + r) >> 1, res = -inf;
if (x <= mid) res = max(res, query2(o * 2, l, mid, x, y));
if (y > mid) res = max(res, query2(o * 2 + 1, mid + 1, r, x, y));
return res;
}
} tree[20];
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
a[i + n] = a[i + 2 * n] = a[i];
}
for (int i = 1; i <= 3 * n; i++)
L[i][0] = max(1, i - a[i]), R[i][0] = min(3 * n, i + a[i]);
for (int j = 1; j <= 18; j++) {
tree[j - 1].build(1, 1, 3 * n, j - 1);
for (int i = 1; i <= 3 * n; i++) {
L[i][j] = tree[j - 1].query1(1, 1, 3 * n, L[i][j - 1], R[i][j - 1]);
R[i][j] = tree[j - 1].query2(1, 1, 3 * n, L[i][j - 1], R[i][j - 1]);
}
}
tree[18].build(1, 1, 3 * n, 18);
for (int i = n + 1; i <= n * 2; i++) {
int ans = 0, l = i, r = i;
for (int j = 18; j >= 0; j--) {
int tl = tree[j].query1(1, 1, 3 * n, l, r),
tr = tree[j].query2(1, 1, 3 * n, l, r);
if (tr - tl + 1 < n) {
ans += (1 << j);
l = tl;
r = tr;
}
}
if (r - l + 1 < n) ans++;
printf("%d ", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
template <class S, class T>
istream& operator>>(istream& is, pair<S, T>& p) {
return is >> p.first >> p.second;
}
template <class T>
istream& operator>>(istream& is, vector<T>& xs) {
for (auto& x : xs) is >> x;
return is;
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << p.first << " " << p.second;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& xs) {
for (unsigned int i = 0; i < xs.size(); ++i) os << (i ? " " : "") << xs[i];
return os;
}
template <class T>
void maxi(T& x, T y) {
if (x < y) x = y;
}
template <class T>
void mini(T& x, T y) {
if (x > y) x = y;
}
void debug(istringstream&) {}
template <char sep = ',', class Head, class... Tail>
void debug(istringstream& iss, Head&& head, Tail&&... tail) {
string name;
getline(iss, name, ',');
cout << sep << name << "=" << head;
debug(iss, forward<Tail>(tail)...);
}
void init_io(int argc, char* argv[]) {
cin.tie(0);
ios_base::sync_with_stdio(false);
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9 + 7;
int main(int argc, char* argv[]) {
init_io(argc, argv);
int T;
cin >> T;
while (T--) {
int N;
cin >> N;
VI xs(N);
cin >> xs;
VI ans(N);
for (int i = (0); i < (N / 2); ++i) {
ans[i] = xs[N - 1 - i];
ans[N - 1 - i] = -xs[i];
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <cstdio>
using namespace std;
// 0A 1X 2Y 3Z 4W 5B 6
typedef struct {
int naw;
int next_1;
int next_0;
}MAP;
int main()
{
char road[150];
MAP ma[6];
ma[0].naw = 0;
ma[0].next_1 = 2;
ma[0].next_0 = 1;
ma[1].naw = 1;
ma[1].next_1 = 3;
ma[1].next_0 = 6;
ma[2].naw = 2;
ma[2].next_1 = 6;
ma[2].next_0 = 1;
ma[3].naw = 3;
ma[3].next_1 = 5;
ma[3].next_0 = 4;
ma[4].naw = 4;
ma[4].next_1 = 2;
ma[4].next_0 = 5;
ma[5].naw = 5;
ma[5].next_1 = 1;
ma[5].next_0 = 2;
while (scanf("%s", road), road[0] != '#'){
int naw = 0;
for (int i = 0;road[i] != '\0'; i++){
if (road[i] == '0'){
naw = ma[naw].next_0;
}
else{
naw = ma[naw].next_1;
}
if(naw == 6) break;
}
if (naw == 5){
puts("Yes");
}
else {
puts("No");
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool mark[1000];
int main() {
long long n, i, l;
double rad = 0, m;
cin >> n >> l;
long long lamp[n + 10];
for (i = 0; i < n; i++) {
scanf("%lld", &lamp[i]);
}
sort(lamp, lamp + n);
rad = max(lamp[0] - 0, l - lamp[n - 1]);
i = 0;
if (lamp[0] == 0) i = 1;
for (; i < n; i++) {
m = (lamp[i] - lamp[i - 1]);
m = m / 2;
rad = max(rad, m);
}
printf("%.12lf\n", rad);
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s,hitachi="";
cin>>s;
for (register int i=1;i<=5;i++)
{
hitachi+="hi";
if (hitachi==s)
return cout<< "Yes\n",0;
}
return cout<<"No\n",0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<long long int> t;
long long int x;
for (int i = 0; i < n; ++i) {
cin >> x;
t.push_back(x);
}
sort(t.begin(), t.end());
long long int tmin = t[0], tmax = t[n - 1];
long long int cost = 0;
long long int tt;
long long int cc = 100 * 1000 + 1;
for (long long int i = tmin; i <= tmax; i++) {
for (int j = 0; j < n; ++j) {
if (t[j] > i + 1) cost += abs(t[j] - (i + 1));
if (t[j] < i - 1) cost += abs(t[j] - (i - 1));
}
if (cost < cc) {
cc = cost;
tt = i;
cost = 0;
}
}
cout << tt << " " << cc;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[30][30];
int data[30][30], common[30][30], b[30][30], dp[(1 << 22)], n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) scanf("%d", &data[i][j]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int sum = 0, x = -(1 << 22);
for (int k = 0; k < n; ++k) {
if (s[k][j] == s[i][j]) {
sum += data[k][j], x = max(x, data[k][j]);
common[i][j] |= (1 << k);
}
}
b[i][j] = sum - x;
}
memset(dp, 0x3f, sizeof(dp)), dp[0] = 0;
int re = (1 << n);
for (int i = 0; i < re; ++i)
for (int j = 0; j < n; ++j)
if ((i & (1 << j)) == 0) {
for (int k = 0; k < m; ++k) {
dp[i | (1 << j)] = min(dp[i | (1 << j)], dp[i] + data[j][k]);
dp[i | common[j][k]] = min(dp[i | common[j][k]], dp[i] + b[j][k]);
}
}
printf("%d\n", dp[re - 1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int c[10];
int main() {
int r1, r2, c1, c2, d1, d2;
cin >> r1 >> r2 >> c1 >> c2 >> d1 >> d2;
int x1, x2, x3, x4;
x2 = (c2 - r2 + d2) / 2;
x3 = (r2 - c2 + d2) / 2;
x1 = r1 - x2;
x4 = c2 - x2;
int flag = 0;
if (x1 + x2 == r1 && x3 + x4 == r2 && x1 + x3 == c1 && x2 + x4 == c2 &&
x1 + x4 == d1 && x2 + x3 == d2)
flag = 1;
c[x1]++;
c[x2]++;
c[x3]++;
c[x4]++;
int sum = 0;
for (int i = 1; i < 10; i++) {
sum += c[i];
if (c[i] > 1) flag = 0;
}
if (sum != 4) flag = 0;
if (flag) {
cout << x1 << " " << x2 << endl;
cout << x3 << " " << x4 << endl;
} else
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T first, char end = 0);
inline void writeChar(int first);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T first = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') first = first * 10 + c - '0', c = getChar();
return s == 1 ? first : -first;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int first) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = first;
}
template <class T>
inline void writeInt(T first, char end) {
if (first < 0) writeChar('-'), first = -first;
char s[24];
int n = 0;
while (first || !n) s[n++] = '0' + first % 10, first /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
const auto pi = acos(-1);
int Log[1 << 21];
const int N = 1 << 20;
void fft(vector<complex<double> > &s, int n, int ok) {
const int lg = Log[n] - 1;
assert((1 << Log[n]) == n);
auto rev = [&](int first) {
int ans = 0;
for (int k = 0; k <= lg; ++k)
if ((first >> k) & 1) ans += 1 << (lg - k);
return ans;
};
for (int i = 0; i < n; ++i)
if (i < rev(i)) swap(s[i], s[rev(i)]);
for (int len = 2; len <= n; len <<= 1) {
const auto ang = 2 * pi * ok / len;
const auto W = complex<double>(cos(ang), sin(ang));
for (int i = 0; i < n; i += len) {
complex<double> w = complex<double>(1, 0);
for (int j = 0; j < len / 2; ++j) {
const complex<double> vv = s[i + j + (len / 2)] * w;
const complex<double> uu = s[i + j];
s[i + j] = uu + vv;
s[i + j + (len / 2)] = uu - vv;
w *= W;
}
}
}
if (ok == -1)
for (int i = 0; i < n; ++i) s[i] /= n;
}
void FFT(const vector<bool> &a, const vector<bool> &b, vector<bool> &c) {
vector<complex<double> > A(a.begin(), a.end()), B(b.begin(), b.end());
int n = max(a.size(), b.size()) * 2;
A.resize(n);
B.resize(n);
fft(A, n, 1);
fft(B, n, 1);
for (int i = 0; i < n; ++i) A[i] *= B[i];
fft(A, n, -1);
c.clear();
for (int i = 0; i < n; ++i) c.push_back(!!(int)(A[i].real() + 0.5));
}
int main(void) {
srand(time(0));
cout << fixed << setprecision(7);
cerr << fixed << setprecision(7);
int n, k;
for (int i = 2; i < (1 << 21); ++i) Log[i] = Log[i / 2] + 1;
n = readInt();
k = readInt();
vector<bool> s(1024, 0);
while (n--) {
int v = readInt();
s[v] = 1;
}
vector<bool> ans;
ans.push_back(1);
while (k) {
if (k & 1) FFT(ans, s, ans);
FFT(s, s, s);
k /= 2;
}
n = ans.size();
int cnt = accumulate(ans.begin(), ans.end(), 0);
for (int i = 0; i < n; ++i)
if (ans[i]) writeInt(i, " \n"[(--cnt) == 0]);
cerr << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms"
<< '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1000005;
const long long SQRTN = 1003;
const long long LOGN = 22;
const double PI = acos(-1);
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
const long long FMOD = 998244353;
const double eps = 1e-9;
void __print(long long x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
mt19937 RNG(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
template <typename T>
T lcm(T a, T b) {
return (a * (b / gcd(a, b)));
}
long long add(long long a, long long b, long long c = MOD) {
long long res = a + b;
return (res >= c ? res % c : res);
}
long long sub(long long a, long long b, long long c = MOD) {
long long res;
if (abs(a - b) < c)
res = a - b;
else
res = (a - b) % c;
return (res < 0 ? res + c : res);
}
long long mul(long long a, long long b, long long c = MOD) {
long long res = (long long)a * b;
return (res >= c ? res % c : res);
}
long long muln(long long a, long long b, long long c = MOD) {
long long res = (long long)a * b;
return ((res % c) + c) % c;
}
long long mulmod(long long a, long long b, long long m = MOD) {
long long q = (long long)(((long double)a * (long double)b) / (long double)m);
long long r = a * b - q * m;
if (r > m) r %= m;
if (r < 0) r += m;
return r;
}
template <typename T>
T binpow(T e, T n) {
T x = 1, p = e;
while (n) {
if (n & 1) x = x * p;
p = p * p;
n >>= 1;
}
return x;
}
template <typename T>
T binpow2(T e, T n, T m = MOD) {
T x = 1, p = e;
while (n) {
if (n & 1) x = mul(x, p, m);
p = mul(p, p, m);
n >>= 1;
}
return x;
}
template <typename T>
T extended_euclid(T a, T b, T &x, T &y) {
T xx = 0, yy = 1;
y = 0;
x = 1;
while (b) {
T q = a / b, t = b;
b = a % b;
a = t;
t = xx;
xx = x - q * xx;
x = t;
t = yy;
yy = y - q * yy;
y = t;
}
return a;
}
template <typename T>
T mod_inverse(T a, T n = MOD) {
T x, y, z = 0;
T d = extended_euclid(a, n, x, y);
return (d > 1 ? -1 : sub(x, z, n));
}
const long long FACSZ = 1e4;
long long fact[FACSZ], ifact[FACSZ];
void precom(long long c = MOD) {
fact[0] = 1;
for (long long i = 1; i < FACSZ; i++) fact[i] = mul(fact[i - 1], i, c);
ifact[FACSZ - 1] = mod_inverse(fact[FACSZ - 1], c);
for (long long i = FACSZ - 1 - 1; i >= 0; i--) {
ifact[i] = mul(i + 1, ifact[i + 1], c);
}
}
vector<long long> primes;
void prime_precom() {
primes.push_back(2);
for (long long x = 3; primes.size() <= MAXN; x += 2) {
bool isPrime = true;
for (auto p : primes) {
if (x % p == 0) {
isPrime = false;
break;
}
if (p * p > x) {
break;
}
}
if (isPrime) {
primes.push_back(x);
}
}
}
long long ncr(long long n, long long k) {
if (n < k) return 0;
if (k == 0) return 1;
long long res = 1;
if (k > n - k) k = n - k;
for (long long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
long long ncr_modp(long long n, long long k, long long c = MOD) {
if (n < k) return 0;
if (k == 0) return 1;
long long res = 1;
if (k > n - k) k = n - k;
for (long long i = 0; i < k; ++i) {
res = mul(res, n - i, c);
res = mul(res, binpow2(i + 1, c - 2, c), c);
}
return res;
}
vector<long long> factors;
void factorize(long long a) {
factors.clear();
for (long long i = 1; i * i <= a; i++) {
if (a % i == 0) {
factors.push_back(i);
factors.push_back(a / i);
}
}
sort(factors.begin(), factors.end());
}
long long ncr_precom(long long n, long long r, long long c = MOD) {
return mul(mul(ifact[r], ifact[n - r], c), fact[n], c);
}
long long ceil(long long a, long long b) { return (a + b - 1) / b; }
bool is_prime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
bool diophantine_checker(long long a, long long b, long long n) {
for (long long i = 0; i * a <= n; i++) {
if ((n - (i * a)) % b == 0) {
return true;
}
}
return false;
}
long long count_divisors(long long n) {
long long c;
long long ans = 1;
for (long long i = 2; i * i <= n; i++) {
c = 0;
while (n % i == 0) {
c++;
n /= i;
}
ans *= (c + 1);
}
if (n > 2) {
return ans * 2;
}
return ans;
}
string to_binary(long long n) {
string r;
while (n != 0) {
r = (n % 2 == 0 ? "0" : "1") + r;
n /= 2;
}
return r;
}
bool ispower2(long long x) { return x && (!(x & (x - 1))); }
unsigned long long mulmodBitwise(unsigned long long a, unsigned long long b,
unsigned long long p) {
a %= p;
b %= p;
if (a <= 0xFFFFFFF && b <= 0xFFFFFFF) {
return (a * b) % p;
}
if (b > a) {
swap(a, b);
}
unsigned long long result = 0;
while (a > 0 && b > 0) {
if (b & 1) {
result += a;
result %= p;
}
a <<= 1;
a %= p;
b >>= 1;
}
return result;
}
unsigned long long mulmod2(unsigned long long a, unsigned long long b,
unsigned long long p) {
a %= p;
b %= p;
if (a <= 0xFFFFFFF && b <= 0xFFFFFFF) {
return (a * b) % p;
}
unsigned long long zeros = 0;
unsigned long long m = p;
while ((m & 0x8000000000000000ULL) == 0) {
zeros++;
m <<= 1;
}
unsigned long long mask = (1 << zeros) - 1;
unsigned long long result = 0;
while (a > 0 && b > 0) {
result += (b & mask) * a;
result %= p;
b >>= zeros;
a <<= zeros;
a %= p;
}
return result;
}
unsigned long long powmod(unsigned long long base, unsigned long long exponent,
unsigned long long p) {
unsigned long long result = 1;
while (exponent > 0) {
if (exponent & 1) {
result = mulmod2(result, base, p);
}
base = mulmod2(base, base, p);
exponent >>= 1;
}
return result;
}
vector<long long> spf;
void sieve() {
spf.resize(MAXN);
spf[1] = 1;
for (long long i = 2; i < MAXN; i++) {
spf[i] = i;
}
for (long long i = 4; i < MAXN; i += 2) {
spf[i] = 2;
}
for (long long i = 3; i * i <= MAXN; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < MAXN; j += i) {
if (spf[j] == j) {
spf[j] = i;
}
}
}
}
}
void pfactor(long long x, vector<long long> &ret) {
while (x != 1) {
ret.push_back(spf[x]);
x = x / spf[x];
}
}
void solvethetestcase() {
long long n;
cin >> n;
vector<vector<long long> > v(n);
map<long long, vector<long long> > make_pair;
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
long long mx = -1;
for (long long j = 0; j < k; j++) {
long long x;
cin >> x;
v[i].push_back(x);
mx = max(mx, x - j);
}
make_pair[mx].push_back(i);
};
vector<long long> id;
for (auto x : make_pair) {
for (auto z : x.second) {
id.push_back(z);
}
}
vector<vector<long long> > order;
for (auto x : id) {
order.push_back(v[x]);
};
long long l = 0, r = 1e12;
while (r - l > 3) {
long long md = (l + r) / 2;
long long cur = md;
bool b = 1;
for (auto x : order) {
for (auto z : x) {
if (z >= cur) {
b = 0;
break;
} else {
cur++;
}
}
if (!b) {
break;
}
}
if (b) {
r = md;
} else {
l = md + 1;
}
}
for (long long i = l; i <= r; i++) {
bool b = 1;
long long cur = i;
for (auto x : order) {
for (auto z : x) {
if (z >= cur) {
b = 0;
break;
} else {
cur++;
}
}
if (!b) {
break;
}
}
if (b) {
cout << i << "\n";
return;
}
}
}
signed main() {
cout << fixed << setprecision(12);
;
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
for (long long testcase = 1; testcase < t + 1; testcase++) {
solvethetestcase();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 11;
typedef int i_N[maxN];
int N, M, K;
set<int> adj[maxN];
i_N deg, mark;
int ans;
pair<int, int> edge[maxN];
void dfs(int u) {
if (mark[u]++) return;
ans--;
for (set<int>::iterator it = adj[u].begin(); it != adj[u].end(); it++) {
int v = *it;
deg[v]--;
adj[v].erase(u);
if (deg[v] < K) dfs(v);
}
adj[u].clear();
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N >> M >> K;
for (int i = 1; i <= M; i++) {
int u, v;
cin >> u >> v;
adj[u].insert(v);
adj[v].insert(u);
deg[u]++;
deg[v]++;
edge[i] = pair<int, int>(u, v);
}
ans = N;
for (int i = 1; i <= N; i++)
if (deg[i] < K) dfs(i);
vector<int> v;
for (int i = M; i; i--) {
v.push_back(ans);
int u = edge[i].first, v = edge[i].second;
if (adj[u].find(v) != adj[u].end()) {
deg[u]--;
deg[v]--;
adj[u].erase(v);
adj[v].erase(u);
}
if (deg[u] < K) dfs(u);
if (deg[v] < K) dfs(v);
}
reverse(v.begin(), v.end());
for (int i = 0; i < M; i++) cout << v[i] << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int CC;
struct str {
int L, P;
char C[15];
bool operator<(const str& S) const {
if (P > S.P) return true;
if (P < S.P) return false;
return (strcmp(C, S.C) < 0);
}
};
str G[101];
int GetPOS(char* A) {
for (int p = (1); p <= (CC); p += (1))
if (strcmp(A, G[p].C) == 0) return p;
CC++;
strcpy(G[CC].C, A);
G[CC].L = strlen(A);
G[CC].P = 0;
return CC;
}
int MOD(int p) { return p > 0 ? p : -1 * p; }
bool InRange(int p, int l, int u) { return p >= l && p <= u; }
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
int MCM(int a, int b) { return a * b / GCD(a, b); }
int MIN2N(int a, int b) {
if (a <= b) return a;
return b;
}
int MAX2N(int a, int b) {
if (a >= b) return a;
return b;
}
int MIN3N(int a, int b, int c) {
if (a <= b && a <= c) return a;
if (b <= c) return b;
return c;
}
int MAX3N(int a, int b, int c) {
if (a >= b && a >= c) return a;
if (b >= c) return b;
return c;
}
bool* m_criba;
void criba(bool*& m, int tam) {
m = new bool[tam + 1];
m[0] = m[1] = false;
for (int i = 2; i <= tam; ++i) m[i] = true;
for (int i = 2; i * i <= tam; ++i)
if (m[i])
for (int h = 2; i * h <= tam; ++h) m[i * h] = false;
}
int ChangeCharByINT(char* num) {
int tmp = 0;
int large = strlen(num) - 1;
if (num[0] != '-') {
for (int p = (0); p <= (large); p += (1)) tmp = 10 * tmp + (num[p] - '0');
} else {
for (int p = (1); p <= (large); p += (1)) tmp = 10 * tmp + (num[p] - '0');
tmp *= -1;
}
return tmp;
}
int r, c, pr, pc, dir, dst, mov, last, f[200], l[200];
char tab[200][200];
int main() {
scanf("%d%d", &r, &c);
last = 0;
for (int rr = (1); rr <= (r); rr += (1)) {
scanf("%s", &tab[rr]);
f[rr] = c;
l[rr] = 1;
}
for (int rr = (1); rr <= (r); rr += (1))
for (int cc = (c); cc >= (1); cc -= (1)) {
tab[rr][cc] = tab[rr][cc - 1];
if (tab[rr][cc] == 'W') {
last = rr;
if (f[rr] > cc) f[rr] = cc;
if (l[rr] < cc) l[rr] = cc;
}
}
mov = 0;
pr = pc = dir = 1;
while (1) {
if (dir == 1) {
dst = 0;
if (l[pr] > pc) dst = l[pr] - pc;
if (pr < last && l[pr + 1] > pc + dst) dst = l[pr + 1] - pc;
mov += dst;
pc += dst;
if (pr < last) {
pr++;
mov++;
dir = -1;
} else
break;
}
if (dir == -1) {
dst = 0;
if (f[pr] < pc) dst = pc - f[pr];
if (pr < last && f[pr + 1] < pc - dst) dst = pc - f[pr + 1];
mov += dst;
pc -= dst;
if (pr < last) {
pr++;
mov++;
dir = 1;
} else
break;
}
}
printf("%d", mov);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 9;
const long long mod = 1e9 + 7;
const long long inf = (1ll << 60);
long long n, a[MX], lvl[MX], par[MX], dp[30][MX], V[30][MX], p[MX];
bool vis[MX];
vector<pair<long long, long long> > v[MX];
void build(long long x, long long p) {
if (vis[x]) return;
vis[x] = 1;
for (auto pp : v[x]) {
long long nxt = pp.first;
if (nxt == p) continue;
par[nxt] = x;
lvl[nxt] = lvl[x] + 1;
V[0][nxt] = pp.second;
build(nxt, x);
}
}
void pro(long long x) {
long long Au = a[x];
long long ver = x;
for (int i = 20; i >= 0; i--) {
long long node = dp[i][x], dis = V[i][x];
if (dis > Au) continue;
x = node;
Au -= dis;
}
p[par[x]]--;
p[par[ver]]++;
}
long long dfs(long long x) {
long long &ret = p[x];
for (auto pp : v[x]) {
long long nxt = pp.first;
if (nxt == par[x]) continue;
ret += dfs(nxt);
}
return ret;
}
int main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 2; i <= n; i++) {
long long x, y;
scanf("%lld%lld", &x, &y);
v[i].push_back({x, y});
v[x].push_back({i, y});
}
build(1, -1);
for (int i = 1; i <= n; i++) dp[0][i] = par[i];
for (int i = 1; i <= 20; i++) {
for (int j = 1; j <= n; j++) {
long long x = dp[i - 1][j];
dp[i][j] = dp[i - 1][x];
V[i][j] = V[i - 1][j] + V[i - 1][x];
}
}
for (int i = 1; i <= n; i++) pro(i);
dfs(1);
for (int i = 1; i <= n; i++) printf("%lld ", p[i]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long l, r;
cin >> l >> r;
if (l - r == 0)
cout << l;
else if (l - r == 3) {
if (l % 3 == 0)
cout << "3";
else
cout << "2";
} else
cout << "2";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[40][40];
int n, h;
int main(void) {
cin >> n >> h;
for (int i = 0; i <= n; ++i) dp[0][i] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
for (int k = 0; k < j; ++k) {
dp[j][i] += dp[k][i - 1] * dp[j - k - 1][i - 1];
}
}
}
cout << dp[n][n] - dp[n][h - 1];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3c3c3c3c;
const long long LINF = 1ll * INF * INF * 2;
const int N = 4100;
const int MOD = 998244353;
int n, m;
long long x[N];
int ans[N][N];
int P[N];
int rev[N];
int cnt[N];
int B = 1;
int _rev(int x) {
if (x == 1) return 1;
return -(1ll * (MOD / x) * (_rev(MOD % x)) % MOD) + MOD;
}
static char buf[1 << 25];
static int idx = 0;
static int bytes = 0;
static inline int _read() {
if (!bytes || idx == bytes) {
bytes = (int)fread(buf, sizeof(buf[0]), sizeof(buf), stdin);
if (!bytes) return 0;
idx = 0;
}
return buf[idx++];
}
static inline int _readInt() {
int x = 0, s = 1;
int c = _read();
while (c <= 32) c = _read();
if (c == '-') s = -1, c = _read();
while (c > 32) x = 10 * x + (c - '0'), c = _read();
if (s < 0) x = -x;
return x;
}
long long pt[N];
void solve() {
int B = 1 << m;
ans[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = n / m; j >= 0; j--) {
for (int k = B - 1; k >= 0; k--) {
int temp = k | (1 << (x[i] - 1));
if (temp == B - 1)
ans[j + 1][0] = (ans[j + 1][0] + ans[j][k]) % MOD;
else
ans[j][temp] = (ans[j][temp] + ans[j][k]) % MOD;
}
}
}
for (int i = 0; i <= n / m; i++) {
for (int k = 0; k < B; k++) pt[i] += ans[i][k];
}
pt[0]--;
for (int i = 0; i <= n; i++) printf("%lld ", pt[i] % MOD);
}
int f[N][N];
void make() {
for (int j = 0; j <= n; j++) {
int b = m;
int pow = 1;
for (int i = 1; i <= m; i++) cnt[i] = 0;
for (int i = j; i < n; i++) {
if (!cnt[x[i]])
b--, cnt[x[i]] = 1;
else {
cnt[x[i]]++;
pow = (1ll * ((1ll * (pow) * (rev[cnt[x[i]] - 1]) % MOD)) *
(P[cnt[x[i]]] - 1) % MOD);
}
if (!b) f[i][j] = (1ll * (pow) * (rev[cnt[x[i]]]) % MOD);
}
}
}
int main(void) {
n = _readInt();
m = _readInt();
for (int i = 0; i < n; i++) x[i] = _readInt();
if (m <= 12) {
solve();
return 0;
}
while (B <= m) B = B + B;
P[0] = 1;
for (int i = 1; i <= n; i++) P[i] = (P[i - 1] + P[i - 1]) % MOD;
for (int i = 1; i <= n; i++) rev[i] = _rev(P[i] - 1);
ans[0][n] = 1;
int pow = 1;
int b = m;
for (int i = n - 1; i >= 0; i--) {
if (!cnt[x[i]])
b--, cnt[x[i]] = 1;
else {
cnt[x[i]]++;
pow = (1ll * ((1ll * (pow) * (rev[cnt[x[i]] - 1]) % MOD)) *
(P[cnt[x[i]]] - 1) % MOD);
}
ans[0][i] = P[n - i];
if (!b) ans[0][i] -= pow;
if (ans[0][i] < 0) ans[0][i] += MOD;
}
make();
int C = n / m;
for (int p = 1; p <= C; p++) {
for (int j = 0; j < n; j++) {
for (int i = j; i < n; i++) {
if (!ans[p - 1][i + 1]) break;
if (f[i][j])
ans[p][j] =
(ans[p][j] + (1ll * (ans[p - 1][i + 1]) * (f[i][j]) % MOD)) % MOD;
}
}
}
ans[0][0]--;
for (int i = 0; i <= n; i++) printf("%d ", ans[i][0]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 5;
int n;
string s, ans;
int main() {
while (scanf("%d", &n) != EOF) {
cin >> s;
ans = string(n, '9');
for (int add = 0; add < 10; add++) {
for (int shift = 0; shift < n; shift++) {
ans = min(ans, s.substr(shift, n - shift) + s.substr(0, shift));
}
for (int i = 0; i < n; i++) {
s[i]++;
if (s[i] > '9') s[i] -= 10;
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const long long mod=1000000007;
int n,po,l,r,mid,ans1,ans2;
long long d[201],K,ma,k,a[201],mi,ans,tot,f[61][61][2],ff[61][61][2],t[61],tmp,len,m,mii[201][24401],le;
struct node
{
long long b,c,d;
int po;
}x[201];
int solve(long long ll,long long r)
{
if (ll==0) return 0;
if (ll==1) return 1;
t[0]=0; ll--;
while (ll) t[++t[0]]=ll%2,ll/=2; len=t[0];
for (int i=1; i<=(t[0]/2); i++) tmp=t[i],t[i]=t[t[0]-i+1],t[t[0]-i+1]=tmp;
memset(f,0,sizeof(f));
f[0][0][1]=1;
for (int i=1; i<=t[0]; i++)
for (int l=0; l<=60; l++)
for (int j=0; j<=1&&j+l<=60; j++)
if (j>t[i])
f[i][l+j][0]+=f[i-1][l][0];
else
if (j<t[i])
f[i][l+j][0]+=f[i-1][l][0]+f[i-1][l][1];
else
f[i][l+j][0]+=f[i-1][l][0],f[i][l+j][1]+=f[i-1][l][1];
t[0]=0;
while (r) t[++t[0]]=r%2,r/=2;
for (int i=1; i<=(t[0]/2); i++) tmp=t[i],t[i]=t[t[0]-i+1],t[t[0]-i+1]=tmp;
memset(ff,0,sizeof(ff));
ff[0][0][1]=1;
for (int i=1; i<=t[0]; i++)
for (int l=0; l<=60; l++)
for (int j=0; j<=1&&j+l<=60; j++)
if (j>t[i])
ff[i][l+j][0]+=ff[i-1][l][0];
else
if (j<t[i])
ff[i][l+j][0]+=ff[i-1][l][0]+ff[i-1][l][1];
else
ff[i][l+j][0]+=ff[i-1][l][0],ff[i][j+l][1]+=ff[i-1][l][1];
for (int i=1; i<=60; i++)
if (f[len][i][0]+f[len][i][1]!=ff[t[0]][i][0]+ff[t[0]][i][1]) return i;
}
bool cmp(node a,node b) {return a.c<b.c;}
int main()
{
//freopen("f.in","r",stdin);
scanf("%d%lld",&n,&K); ma=0;
for (int i=1; i<=n; i++) {scanf("%lld",&a[i]); if (a[i]>ma) ma=a[i];}
ma*=2ll;
sort(a+1,a+1+n);
x[0].c=-1; tot=0;
memset(mii,0,sizeof(mii));
for (k=1; K>=0&&k<=ma; k*=2ll,K--)
{
mi=(2e18);
for (int i=1; i<=n; i++)
{
x[i].c=a[i]%k; x[i].b=a[i]/k; x[i].d=x[i].b; x[i].po=i;
if (x[i].b<mi) mi=x[i].b;
}
sort(x+1,x+n+1,cmp);
//printf("%d\n",x[2].d);
for (int i=1; i<=n; i++)
{
if (mi<0) break;
if (x[i].c!=x[i-1].c)
{
ans=solve(x[i-1].c+1,x[i].c);
if (ans>K) {if (x[i].b-1<mi) mi=x[i].b-1; x[i].d--; continue;}
//printf("%lld %lld %lld\n",c[i-1]+1,x[i].c,ans);
po=1;
for (int j=1; j<=n; j++) d[x[j].po]=x[j].d;
//if (d[1]==1&&d[2]==2&&d[3]==4) {printf("%lld %lld %lld %lld\n",K,ans,x[i-1].c+1,x[i].c);}
for (int j=2; j<=n; j++)
if (d[j]!=d[j-1])
{
if (d[j]>d[j-1]+1) {po=0; break;}
if (po==1) po=j;
else {po=0; break;}
}
// printf("#####\n");
// printf("%d %lld %lld %lld\n",i,K,x[i-1].c+1,x[i].c);
// printf("*****\n");
// for (int j=1; j<=n; j++) printf("%d ",d[j]); printf("\n");
// printf("*****\n");
if (!po)
{
if (K-ans>mi) tot=(tot+mi+1)%mod;
else tot=(tot+K-ans+1)%mod;
} else
{
//printf("%lld %lld %lld %lld\n",K,ans,mi,tot);
// printf("%lld\n",tot);
if (k>ma) printf("%d\n",po);
if (K-ans>mi) m=mi; else m=K-ans;
l=1; r=mii[po][0]; ans1=0; le=d[1]-m; if (le<0) le=0;
// printf("%d %d\n",po,mii[po][0]);
// for (int j=1; j<=mii[po][0]; j++) printf("%d ",mii[po][j]); printf("\n");
// printf("%d %d\n",le,d[1]);
while (l<=r)
{
mid=(l+r)>>1;
if (mii[po][mid]<le) ans1=mid,l=mid+1; else r=mid-1;
}
l=1; r=mii[po][0]; ans2=0;
while (l<=r)
{
mid=(l+r)>>1;
if (mii[po][mid]<=d[1]) ans2=mid,l=mid+1; else r=mid-1;
}
if (ans1==ans2)
{
if (!(ans1&1))
{
tot=(tot+d[1]-le+1)%mod;
mii[po][0]+=2;
for (int j=mii[po][0]; j>ans1+2; j--) mii[po][j]=mii[po][j-2];
mii[po][ans1+2]=d[1]; mii[po][ans1+1]=le;
}
} else
{
if (ans1&1)
{
if (ans2&1)
{
for (int j=ans1+1; j<ans2; j+=2) tot=(tot+mii[po][j+1]-mii[po][j]-1)%mod;
mii[po][0]-=ans2-ans1;
for (int j=ans1+1; j<=mii[po][0]; j++) mii[po][j]=mii[po][j+ans2-ans1];
} else
{
for (int j=ans1+1; j<ans2; j+=2) tot=(tot+mii[po][j+1]-mii[po][j]-1)%mod;
tot=(tot+d[1]-mii[po][ans2])%mod;
mii[po][0]-=ans2-ans1-1; mii[po][ans1+1]=d[1];
for (int j=ans1+2; j<=mii[po][0]; j++) mii[po][j]=mii[po][j+ans2-ans1-1];
}
} else
{
if (ans2&1)
{
tot=(tot+mii[po][ans1+1]-le)%mod;
for (int j=ans1+2; j<ans2; j+=2) tot=(tot+mii[po][j+1]-mii[po][j]-1)%mod;
mii[po][0]-=ans2-ans1-1; mii[po][ans1+1]=le;
for (int j=ans1+2; j<=mii[po][0]; j++) mii[po][j]=mii[po][j+ans2-ans1-1];
} else
{
tot=(tot+mii[po][ans1+1]-le)%mod; tot=(tot+d[1]-mii[po][ans2])%mod;
for (int j=ans1+2; j<ans2; j+=2) tot=(tot+mii[po][j+1]-mii[po][j]-1)%mod;
mii[po][0]-=ans2-ans1-2; mii[po][ans1+1]=le; mii[po][ans1+2]=d[1];
for (int j=ans1+3; j<=mii[po][0]; j++) mii[po][j]=mii[po][j+ans2-ans1-2];
}
}
}
// printf("%lld\n",tot);
// printf("---------\n");
//printf("%lld %lld %lld %lld\n",k,d[1],m,mii[po]);
/*if (x[1].d-m<mii[po])
{
//printf("%lld %lld\n",mii[po],x[1].d);
if (mii[po]>x[1].d) tot=(tot+m+1)%mod; else tot=(tot+mii[po]-x[1].d+m)%mod;
//printf("%lld %lld %lld %lld %d\n",x[1].d,m,tot,mii[po],po);
mii[po]=x[1].d-m;
}*/
}
//printf("%lld %lld\n",x[i-1].c+1,x[i].c);
//for (int j=1; j<=n; j++) printf("%lld %lld %lld %lld %lld\n",x[j].d,K,ans,mi,tot); printf("\n");
}
//if (i==2) printf("%d\n",x[i].d);
if (x[i].b-1<mi) mi=x[i].b-1; x[i].d--;
}
}
/*for (int i=1; i<=n; i++)
{
printf("---------\n");
printf("%d\n",mii[i][0]);
for (int j=1; j<=mii[i][0]; j++) printf("%d ",mii[i][j]); printf("\n");
}*/
printf("%lld\n",tot);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,cnt=0;
long long a;
map<long long,bool>mp;
cin>>n;
while(n--){
cin>>a;
if(mp[a]){
cnt--;
mp[a]=0;
}
else{
mp[a]=1;
cnt++;
}
}
cout<<cnt;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define ll long long
#define pq priority_queue
#define mp make_pair
#define pii pair<int,int>
#define mod 998244353
int lowbit(int x) {return x&(-x);}
int n,d;
int a[200010];
vector <pair<ll,pii> > e;
struct UF{
int p[200010],rank[200010];
void init() {
for (int i=0;i<200010;i++) p[i]=i;
for (int i=0;i<200010;i++) rank[i]=0;
}
int getf(int x){
if (p[x]==x) return x;
return getf(p[x]);
}
bool same(int x,int y) {
return getf(x)==getf(y);
}
void unite(int x,int y) {
int xx=getf(x);
int yy=getf(y);
if (xx!=yy) {
if (rank[xx]<rank[yy]) p[xx]=yy;
else {
p[yy]=xx;
if (rank[xx]==rank[yy]) rank[xx]++;
}
}
}
}uf;
void solve(int l,int r) {
if (l==r) return;
int mid=l+r>>1;
ll mn=1e18;
int pl,pr;
for (int i=l;i<=mid;i++) {
ll cur=(ll)a[i]-(ll)d*(ll)i;
if (cur<mn) {
mn=cur;
pl=i;
}
}
mn=1e18;
for (int j=mid+1;j<=r;j++) {
ll cur=a[j]+(ll)d*(ll)j;
if (cur<mn) {
mn=cur;
pr=j;
}
}
for (int i=mid+1;i<=r;i++) {
ll vl=(ll)a[pl]-(ll)d*(ll)pl;
ll vr=(ll)a[i]+(ll)d*(ll)i;
e.pb(mp(vl+vr,mp(pl,i)));
}
for (int i=l;i<=mid;i++) {
ll vl=(ll)a[i]-(ll)d*(ll)i;
ll vr=(ll)a[pr]+(ll)d*(ll)pr;
e.pb(mp(vl+vr,mp(i,pr)));
}
solve(l,mid);
solve(mid+1,r);
}
int main(){
scanf("%d%d",&n,&d);
for (int i=0;i<n;i++) scanf("%d",&a[i]);
solve(0,n-1);
sort(e.begin(),e.end());
uf.init();
ll ans=0ll;
for (int i=0;i<e.size();i++) {
int u=e[i].se.fi,v=e[i].se.se;
if (!uf.same(u,v)) {
uf.unite(u,v);
ans+=e[i].fi;
// cout<<e[i].fi<<" "<<u<<" "<<v<<endl;
}
}
cout<<ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int s, k, i, n, j;
scanf("%d", &n);
int a[1000], b[1000];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
std::sort(a, a + n);
k = n;
for (i = 0; i < n; i++) {
b[i] = 1;
}
for (i = 0; i < n; i = i + b[i])
for (j = i + 1; j < n; j++) {
if (a[i] == a[j]) {
k = k - 1;
b[i] = b[i] + 1;
}
}
std::sort(b, b + n);
printf("%d\n%d\n", b[n - 1], k);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define nn 65536*4
#define N 2005
#define ll long long
#define mod 1000000007
ll f[nn],rf[nn];int n;
ll qpow(ll x,ll y)
{
ll res=1;
while(y)
{
if(y&1) res=res*x%mod;
x=x*x%mod;y=y/2;
}
return res;
}
ll a[nn],b[nn];
ll dp[N+N][N+N];
ll bas=N-2;
ll C(ll x,ll y)
{
return f[y]*rf[x]%mod*rf[y-x]%mod;
}
int main()
{
f[0]=1;for(int i=1;i<nn;i++) f[i]=f[i-1]*i%mod;
rf[nn-1]=qpow(f[nn-1],mod-2);
for(int i=nn-2;i>=0;i--) rf[i]=rf[i+1]*(i+1)%mod;
cin>>n;ll ans=0;
for(int i=1;i<=n;i++)
{
scanf("%lld%lld",&a[i],&b[i]);
ans=ans-C(a[i]+a[i],b[i]+b[i]+a[i]+a[i]),ans%=mod;
dp[-a[i]+bas][-b[i]+bas]++;
}
for(int i=1;i<N+N;i++)
{
for(int j=1;j<N+N;j++)
{
dp[i][j]=dp[i][j]+dp[i-1][j]+dp[i][j-1];
dp[i][j]%=mod;
}
}
for(int i=1;i<=n;i++)
{
ans+=dp[a[i]+bas][b[i]+bas];
ans%=mod;
}
ans+=mod;ans%=mod;ans=ans*qpow(2,mod-2)%mod;
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<string> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int c = 0, d = 0;
for (long long int i = 0; i < v[0].size(); i++) {
for (long long int j = 0; j < n; j++) {
if (v[j][i] == v[0][i]) {
c++;
}
}
if (c != n) {
cout << d << endl;
return 0;
} else {
c = 0;
d++;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define endl '\n'
#define fi first
#define se second
#define MOD(n,k) ( ( ((n) % (k)) + (k) ) % (k))
#define forn(i,n) for (int i = 0; i < n; i++)
#define forr(i,a,b) for (int i = a; i <= b; i++)
#define all(v) v.begin(), v.end()
#define pb(x) push_back(x)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
const int MX = 5005, mod = 1000000007;
int n, a, b, mem[MX][MX][2], mem2[MX][MX];
ll pot (ll b, int p) {
ll res = 1;
while (p) {
if (p & 1) (res *= b) %= mod;
(b *= b) %= mod;
p /= 2;
}
return res;
}
void sum (int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
int dp (int i, int j, int f);
int dp2 (int i, int j) {
if (i < 0) return 0;
int &res = mem2[i][j];
if (res != -1) return res;
res = 0;
sum(res, dp(i, j, 1));
sum(res, dp2(i - 1, j + 1));
return res;
}
int dp (int i, int j, int f) {
if (f == 0 && j >= a) return 0;
if (f == 1 && j >= b) return 0;
if (!i) return 1;
int &res = mem[i][j][f];
if (res != -1) return res;
res = 0;
sum(res, dp(i - 1, j + 1, f));
sum(res, dp(i - 1, 1, f ^ 1));
if (i == n || (j && f)) {
sum(res, dp2(i - a - 1, j + a + 1));
if (j && f && i >= a)
sum(res, dp(0, j + i, f));
}
return res;
}
int main () {
ios_base::sync_with_stdio(0); cin.tie(0);
memset(mem, -1, sizeof(mem));
memset(mem2, -1, sizeof(mem2));
cin >> n >> a >> b;
if (a > b) swap(a, b);
cout << MOD(pot(2, n) - dp(n, 0, 0), mod) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long N;
cin >> N;
long long ans=0;
for(auto i=1;i<=N;i++)ans+=(i+(N/i*i))*(N/i)/2;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 3;
const int MOD = 1e9 + 7;
int pow3[MAX];
int pre[MAX][4];
int add(int a, int b) { return (a + b < MOD) ? (a + b) : (a + b - MOD); }
int sub(int a, int b) { return (a - b >= 0) ? (a - b) : (a - b + MOD); }
int mul(int a, int b) { return (a * 1LL * b) % MOD; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
pow3[0] = 1LL;
for (int i = 1; i < MAX; i++) pow3[i] = mul(3, pow3[i - 1]);
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == '?')
pre[i + 1][3]++;
else
pre[i + 1][s[i] - 'a']++;
}
for (int i = 0; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
pre[j][i] += pre[j - 1][i];
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (s[i - 1] == 'b' or s[i - 1] == '?') {
int la = pre[i - 1][0], rc = pre[n][2] - pre[i][2];
int lq = pre[i - 1][3], rq = pre[n][3] - pre[i][3];
int q = lq + rq;
int jog = mul(mul(la, rc), pow3[q]);
ans = add(ans, jog);
jog = mul(mul(lq, rq), pow3[q - 2]);
ans = add(ans, jog);
jog = mul(mul(la, rq), pow3[q - 1]);
ans = add(ans, jog);
jog = mul(mul(lq, rc), pow3[q - 1]);
ans = add(ans, jog);
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T min(T &a, T &b) {
return a < b ? a : b;
}
template <class T>
inline T max(T &a, T &b) {
return a > b ? a : b;
}
template <class T>
void read(T &x) {
char ch;
while ((ch = getchar()) && !isdigit(ch))
;
x = ch - '0';
while ((ch = getchar()) && isdigit(ch)) x = x * 10 + ch - '0';
}
struct point {
int x, y;
point() {}
point(int _x, int _y) : x(_x), y(_y) {}
};
int n;
int main() {
scanf("%d", &n);
if (n & 1) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++)
if (((j + 1) / 2 + (k + 1) / 2) & 1)
printf(i & 1 ? "w" : "b");
else
printf(i & 1 ? "b" : "w");
puts("");
}
puts("");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int bits[1000];
int main() {
int n, sum = 0;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> bits[i];
}
bool flag = false;
for (int i = 0; i < n; ++i) {
if (!bits[i] && flag) {
sum += 1;
flag = false;
}
if (bits[i]) {
flag = true;
sum++;
}
}
sum += flag;
cout << max(sum - 1, 0) << "\n";
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int f(int a,int b,int c){return(a+c)*4+b*9;}
int I[1000],a[1000],b[1000],c[1000];
int P,Q,R,C;
int main()
{
int n;
while(cin>>n,n)
{
for(int i=0;i<n;i++)cin>>I[i]>>a[i]>>b[i]>>c[i];
cin>>P>>Q>>R>>C;
int cnt=0;
for(int i=0;i<n;i++)
{
if(a[i]>P)continue;
if(b[i]>Q)continue;
if(c[i]>R)continue;
if(f(a[i],b[i],c[i])>C)continue;
cnt++;
cout<<I[i]<<endl;
}
if(!cnt)cout<<"NA"<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007ll;
inline void print(char pt) { printf("%c\n", pt); }
inline void print(int pt) { printf("%d\n", pt); }
inline void print(long long pt) { printf("%I64d\n", pt); }
inline void print(double pt) { printf("%f\n", pt); }
inline void print(char pt[]) { printf("%s\n", pt); }
inline void scan(int &pt) { scanf("%d", &pt); }
inline void scan(char &pt) { scanf("%c", &pt); }
inline void scan(long long &pt) { scanf("%I64d", &pt); }
inline void scan(double &pt) { scanf("%lf", &pt); }
inline void scan(char pt[]) { scanf("%s", pt); }
struct pii {
int a;
int b;
friend int operator<(pii a, pii b) {
if (a.a != b.a) return a.a < b.a;
return a.b > b.b;
}
};
struct str {
char val[200];
str() { memset(val, 0, sizeof(val)); }
friend int operator<(str a, str b) { return strcmp(a.val, b.val) < 0; }
};
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
long long lcm(long long x, long long y) { return x * (y / gcd(x, y)); }
int bits[50];
void getbits() {
for (int i = 0; i < 30; i++) {
bits[i] = 1 << i;
}
}
struct piii {
int li;
int ri;
int l1;
int l2;
int r1;
int r2;
friend int operator<(piii a, piii b) { return a.li < b.li; }
};
long long Q_pow(long long x, long long y) {
long long res = 1;
while (y) {
if (y % 2 == 1) {
res *= x;
res %= MOD;
}
x = x * x;
x %= MOD;
y /= 2;
}
return res;
}
long long extend_gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0 && b == 0) return -1;
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extend_gcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
long long mod_reverse(long long a, long long MOD) {
long long x, y;
long long d = extend_gcd(a, MOD, x, y);
if (d == 1)
return (x % MOD + MOD) % MOD;
else
return -1;
}
int tmp;
int n, m, k;
char stra[200005];
int lasta[200005];
int nexta[200005];
int main() {
scan(stra);
int lena = strlen(stra);
for (int i = 0; i < lena; i++) {
lasta[i] = i - 1;
nexta[i] = i + 1;
}
int biginposa = 0;
for (int i = 0; i < lena;) {
if (stra[i] == stra[nexta[i]]) {
if (lasta[i] == -1) {
biginposa = nexta[nexta[i]];
lasta[biginposa] = -1;
i = biginposa;
continue;
} else {
nexta[lasta[i]] = nexta[nexta[i]];
lasta[nexta[nexta[i]]] = lasta[i];
i = lasta[i];
continue;
}
} else {
i = nexta[i];
}
}
for (int i = biginposa; i < lena; i = nexta[i]) {
printf("%c", stra[i]);
}
print("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
double eps = 0.0000001;
struct point {
double x, y;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long a, b, c;
cin >> a >> b >> c;
cout << fixed << setprecision(8);
point q, p;
cin >> q.x >> q.y >> p.x >> p.y;
double ans = fabs(q.x - p.x) + fabs(q.y - p.y);
double res;
if (a == 0 || b == 0) {
cout << ans;
return 0;
}
vector<point> w(4);
w[0].x = q.x;
w[0].y = -1. * (a * q.x + c) / b;
w[1].y = q.y;
w[1].x = -1. * (b * q.y + c) / a;
w[2].x = p.x;
w[2].y = -1. * (a * p.x + c) / b;
w[3].y = p.y;
w[3].x = -1. * (b * p.y + c) / a;
for (int i = 0; i < 2; i++) {
for (int j = 2; j < 4; j++) {
res = fabs(q.x - w[i].x) + fabs(q.y - w[i].y);
res += sqrt((w[i].x - w[j].x) * (w[i].x - w[j].x) +
(w[i].y - w[j].y) * (w[i].y - w[j].y));
res += fabs(p.x - w[j].x) + fabs(p.y - w[j].y);
ans = min(ans, res);
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int l[150];
string s;
cin >> s;
string ans;
int mx = 0;
for (int j = 26; j >= 0; j--) {
for (int i = mx; i < s.size(); i++) {
if (s[i] == 'a' + j) {
mx = i;
ans += s[i];
}
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long heights[300001], check[300001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int columns;
cin >> columns;
long long white = 0, black = 0;
int p = 0;
for (int i{1}; i <= columns; ++i) {
cin >> heights[i];
if (p) {
white += heights[i] / 2;
black += heights[i] - heights[i] / 2;
} else {
white += heights[i] - heights[i] / 2;
black += heights[i] / 2;
}
p = !p;
}
cout << min(black, white);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve_fast(int n) {
vector<vector<int>> ds(n + 1);
for (int i = 2; i <= n; i++) {
for (int j = i; j <= n; j += i) {
ds[j].push_back(i);
}
}
vector<int> ps;
for (int i = 1; i <= n; i++) {
if (ds[i].size() < 2) {
ps.push_back(i);
}
}
vector<pair<int, int>> sz;
sz.push_back({1, ps.size()});
vector<bool> taken(n + 1);
for (int p : ps) {
taken[p] = true;
}
vector<bool> seen(n + 1);
while (sz.back().second < n) {
int t = sz.back().first;
t++;
int cnt = sz.back().second;
for (int pos = 0; pos < ps.size() && t * 1ll * ps[pos] <= n && ps[pos] <= t;
pos++) {
int cur = t * ps[pos];
if (taken[cur]) {
continue;
}
auto it = upper_bound(ds[cur].begin(), ds[cur].end(), t);
bool ok = true;
for (auto i = it; i != ds[cur].end(); i++) {
if (seen[*i]) {
ok = false;
break;
}
}
if (!ok) {
continue;
}
for (auto i = it; i != ds[cur].end(); i++) {
seen[*i] = true;
}
cnt++;
taken[cur] = true;
}
sz.push_back({t, cnt});
}
int pos = 0;
for (int i = 2; i <= n; i++) {
while (sz[pos].second < i) {
++pos;
}
cout << sz[pos].first << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
int n;
cin >> n;
solve_fast(n);
}
| 6 |
#include <bits/stdc++.h>
const int MAX_N = 505 * 505;
const double eps = 1e-6;
const int inf = (int)1e9 + 123;
using namespace std;
int pr[MAX_N], sz[MAX_N], h[MAX_N];
int Parent(int a) {
if (a == pr[a]) return a;
return pr[a] = Parent(pr[a]);
}
void Union(int a, int b) {
a = Parent(a), b = Parent(b);
if (a == b) return;
if (h[a] < h[b]) swap(a, b);
pr[b] = a;
sz[a] += sz[b];
h[a] += (h[a] == h[b]);
}
int cnt[MAX_N];
int all;
void add(int x) {
if (!cnt[x]) all += sz[x];
cnt[x]++;
}
void del(int x) {
cnt[x]--;
if (!cnt[x]) all -= sz[x];
}
char a[505][505];
int n, k;
int sum[505][505];
int moves[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
int id(int x, int y) { return (x - 1) * n + y - 1; }
int get_sum(int x, int y, int x2, int y2) {
return sum[x2][y2] - sum[x - 1][y2] - sum[x2][y - 1] + sum[x - 1][y - 1];
}
void Add(int x, int y) {
for (int i = 0; i < n * n; i++) cnt[i] = 0;
all = 0;
for (int i = x; i <= x + k - 1; i++)
for (int j = y; j <= y + k - 1; j++)
if (a[i][j] == '.') add(Parent(id(i, j)));
if (x > 1)
for (int j = y; j <= y + k - 1; j++)
if (a[x - 1][j] == '.') add(Parent(id(x - 1, j)));
if (x + k <= n)
for (int j = y; j <= y + k - 1; j++)
if (a[x + k][j] == '.') add(Parent(id(x + k, j)));
if (y + k <= n)
for (int i = x; i <= x + k - 1; i++)
if (a[i][y + k] == '.') add(Parent(id(i, y + k)));
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
sum[i][j] =
sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + (a[i][j] == 'X');
}
for (int i = 0; i < n * n; i++) pr[i] = i, sz[i] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
for (int k = 0; k < 4; k++) {
int ni = i + moves[k][0], nj = j + moves[k][1];
if (ni > 0 && ni <= n && nj > 0 && nj <= n && a[i][j] == '.' &&
a[ni][nj] == '.')
Union(id(i, j), id(ni, nj));
}
}
int ans = 0;
for (int i = 1; i + k - 1 <= n; i++) {
Add(i, 1);
for (int j = 1; j + k - 1 <= n; j++) {
ans = max(ans, all + get_sum(i, j, i + k - 1, j + k - 1));
if (j > 1)
for (int i2 = i; i2 <= i + k - 1; i2++)
if (a[i2][j - 1] == '.') del(Parent(id(i2, j - 1)));
if (i > 1 && a[i - 1][j] == '.') del(Parent(id(i - 1, j)));
if (i + k <= n && a[i + k][j] == '.') del(Parent(id(i + k, j)));
if (i > 1 && a[i - 1][j + k] == '.') add(Parent(id(i - 1, j + k)));
if (i + k <= n && a[i + k][j + k] == '.') add(Parent(id(i + k, j + k)));
if (j + k + 1 <= n)
for (int i2 = i; i2 <= i + k - 1; i2++)
if (a[i2][j + k + 1] == '.') add(Parent(id(i2, j + k + 1)));
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-15;
const int maxN = 1 * 100000 + 10, mod = (int)1e9 + 7;
int n;
vector<int> v[maxN];
char rang[maxN];
bool mark[maxN];
int zir[maxN];
pair<int, int> pp;
pair<int, int> who(int i, int maxx) {
mark[i] = 1;
zir[i] = 0;
bool vb = 1;
for (int j = 0; j < v[i].size(); ++j) {
if (mark[v[i][j]] == 0) {
pp = who(v[i][j], maxx);
if (pp.first != -1) {
mark[i] = 0;
return pp;
}
if (pp.second > maxx / 2) vb = 0;
zir[i] += pp.second;
}
}
mark[i] = 0;
if (maxx - zir[i] - 1 <= maxx / 2 && vb) return make_pair(i, zir[i] + 1);
return make_pair(-1, zir[i] + 1);
}
void tree(int r, int i, int maxx) {
int p = who(i, maxx).first;
if (p == -1) p = i;
rang[p] = 'A' + r;
mark[p] = 1;
for (int j = 0; j < v[p].size(); ++j)
if (mark[v[p][j]] == 0) tree(r + 1, v[p][j], maxx / 2);
}
int main(void) {
ios_base::sync_with_stdio(0);
int x, y;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
cin >> x >> y;
x--;
y--;
v[x].push_back(y);
v[y].push_back(x);
}
tree(0, 0, n);
for (int i = 0; i < n; ++i) printf("%c ", rang[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
long long s;
int x[100000];
multiset<int> all;
int main() {
scanf("%d%d", &n, &m);
scanf("%I64d", &s);
for (int i = 0; i < n; i++) scanf("%d", &x[i]);
int ans = n;
long long cur = 0;
for (int i = n - 2; i >= 0; i--) {
if (cur + x[i] > s) ans = i + 1;
all.insert(x[i]);
cur += x[i];
if (((int)(all).size()) > m - 1) {
cur -= *all.begin();
all.erase(all.begin());
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int dr[] = {0, -1, 0, 1, -1, 1, 1, -1};
const int dc[] = {1, 0, -1, 0, 1, 1, -1, -1};
const double eps = 1e-9;
template <class T>
void print(T const &x) {
ostringstream os;
os << x;
cout << os.str() << endl;
}
template <class T>
void print(vector<T> const &v) {
ostringstream os;
for (int i = 0; i < v.size(); ++i) {
if (i) os << ' ';
os << v[i];
}
cout << os.str() << endl;
}
template <class T>
void print(vector<vector<T> > const &v) {
ostringstream os;
for (int i = 0; i < v.size(); ++i) {
for (int j = 0; j < v[i].size(); ++j) {
if (j) os << ' ';
os << v[i][j];
}
os << endl;
}
cout << os.str() << endl;
}
template <class T>
void print(valarray<T> const &v) {
ostringstream os;
for (int i = 0; i < v.size(); ++i) {
if (i) os << ' ';
os << v[i];
}
cout << os.str() << endl;
}
template <class T>
int sz(const T &c) {
return (int)c.size();
}
template <class T>
void srt(T &c) {
std::sort(c.begin(), c.end());
}
template <class T>
void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
T sqr(T x) {
return x * x;
}
template <class T, class U>
T cast(U x) {
ostringstream os;
os << x;
T res;
istringstream is(os.str());
is >> res;
return res;
}
template <class T>
vector<T> split(string s, string x = " ") {
vector<T> res;
for (int i = 0; i < s.size(); i++) {
string a;
while (i < (int)s.size() && x.find(s[i]) == string::npos) a += s[i++];
if (!a.empty()) res.push_back(cast<T>(a));
}
return res;
}
template <class T>
bool inside(T r, T c, T R, T C) {
return r >= 0 && r < R && c >= 0 && c < C;
}
int a[128][128];
int b[128][128];
int vis[128][128];
int w, h;
int dfs(int x, int y) {
if (!inside(x, y, w, h)) return 0;
if (vis[x][y]) return 0;
vis[x][y] = 1;
int res = 1;
if (x < w - 1 && !a[x + 1][y]) res += dfs(x + 1, y);
if (x > 0 && !a[x][y]) res += dfs(x - 1, y);
if (y < h - 1 && !b[x][y + 1]) res += dfs(x, y + 1);
if (y > 0 && !b[x][y]) res += dfs(x, y - 1);
return res;
}
int main(int argc, char *argv[]) {
int n;
cin >> w >> h >> n;
for (int i(0), _n(n); i < _n; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
for (int y(y1), _b(y2 - 1); y <= _b; ++y) {
a[x1][y] = 1;
}
}
if (y1 == y2) {
for (int x(x1), _b(x2 - 1); x <= _b; ++x) {
b[x][y1] = 1;
}
}
}
vector<int> res;
for (int i(0), _n(w); i < _n; ++i) {
for (int j(0), _n(h); j < _n; ++j) {
if (!vis[i][j]) {
int x = dfs(i, j);
res.push_back(x);
}
}
}
srt(res);
print(res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long d[100003], sum[403], shelf[403];
int n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
long long x;
int t;
cin >> t;
for (int j = 1; j <= t; j++) {
cin >> x;
sum[j] = ((j == 1) ? 0LL : sum[j - 1]) + x;
}
memset(shelf, 0LL, sizeof(shelf));
for (int l = 0; l <= t; l++)
for (int r = 0; r <= t; r++)
shelf[l + r] = max(shelf[l + r], sum[l] + sum[t] - sum[t - r]);
for (int k = m; k >= 0; k--)
for (int j = min(k, t); j > 0; j--) d[k] = max(d[k], d[k - j] + shelf[j]);
}
cout << d[m] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100000];
int main() {
int n, k, ans = 0, i;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
if (k % 2 == 0) {
for (i = 0; i < n; i++) {
if (a[i] == 2) {
ans ^= 2;
} else if (a[i] % 2 == 0 || a[i] == 1) {
ans ^= 1;
}
}
} else {
for (i = 0; i < n; i++) {
if (a[i] == 1 || a[i] == 3) {
ans ^= 1;
} else if (a[i] % 2 == 0 && a[i] > 2) {
int c = 0;
while (a[i] % 2 == 0) {
a[i] /= 2;
c++;
}
if (c % 2 == 0 && a[i] != 3) {
ans ^= 2;
} else if (c % 2 == 1 && a[i] == 3) {
ans ^= 2;
} else {
ans ^= 1;
}
}
}
}
if (ans == 0) {
puts("Nicky");
} else {
puts("Kevin");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool flag = true;
int one, two, three, flag12 = 0, flag23 = 0, flag13 = 0;
cin >> one >> two >> three;
while (!(one == 0 && two == 0 && three == 0)) {
if ((one == 0 && two == 0 && three != 0) ||
(one != 0 && two == 0 && three == 0) ||
(one == 0 && two != 0 && three == 0)) {
flag = false;
cout << "Impossible";
break;
}
if (one >= two && one >= three && one != 0) {
if (two != 0) {
one--;
two--;
flag12++;
}
if (three != 0 && one != 0) {
one--;
three--;
flag13++;
}
}
if (two >= one && two >= three && two != 0) {
if (three != 0 && two != 0) {
two--;
three--;
flag23++;
}
if (one != 0 && two != 0) {
one--;
two--;
flag12++;
}
}
if (three >= one && three >= two && three != 0) {
if (three != 0 && two != 0) {
two--;
three--;
flag23++;
}
if (one != 0 && three != 0) {
one--;
three--;
flag13++;
}
}
}
if (flag) cout << flag12 << " " << flag23 << " " << flag13;
return 0;
}
| 2 |
#include<stdio.h>
#include<vector>
#include<iostream>
#include<map>
#include<tuple>
using namespace std;
typedef long long ll;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
std::vector<ll> extended_gcd(ll a, ll b){ //ax+by=zとなる(x,y,z)
ll s=0;
ll old_s=1;
ll t=1;
ll old_t=0;
ll r=b;
ll old_r=a;
while(r){
long q =old_r / r;
std::swap(s, old_s); s-=q*old_s;
std::swap(t, old_t); t-=q*old_t;
std::swap(r, old_r); r-=q*old_r;
}
//cout << old_r << " " << old_s << " " << old_t << endl;
std::vector<ll> ans = {old_r, old_s, old_t};
return ans;
}
int main(){
ll a,b;
cin >> a >> b;
auto ans = extended_gcd(a,b);
cout << ans[1] << " " << ans[2] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int moment;
bool T[26];
for (int i = 0; i < 26; i++) {
T[i] = 0;
}
int shoks = 0;
int shoks2 = 0;
bool give = 1;
for (int i = 0; i < n; i++) {
char c;
string s;
cin >> c >> s;
if (c == '!') {
bool B[26];
for (int i = 0; i < 26; i++) {
B[i] = 0;
}
for (int i = 0; i < s.size(); i++) {
B[s[i] - 'a'] = 1;
}
for (int i = 0; i < 26; i++) {
if (!B[i]) T[i] = 1;
}
if (give) {
shoks++;
}
shoks2++;
}
if (c == '.') {
for (int i = 0; i < s.size(); i++) {
T[s[i] - 'a'] = 1;
}
}
if (c == '?' && i != n - 1) {
if (give) shoks++;
shoks2++;
T[s[0] - 'a'] = 1;
}
int sum = 0;
for (int i = 0; i < 26; i++) {
sum += T[i];
}
if (sum == 25) give = 0;
}
cout << shoks2 - shoks << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 7;
struct Query {
int type, v;
int id, t;
bool operator<(const Query& a) const { return id < a.id; }
} a[mx], b[mx];
int ans[mx], vis[mx];
int x[mx];
void cdq(int l, int r) {
if (l >= r) return;
int mid = (l + r) >> 1;
cdq(l, mid);
cdq(mid + 1, r);
int t1 = l, t2 = mid + 1;
for (int i = l; i <= r; i++) {
if ((t1 <= mid && a[t1].t <= a[t2].t) || t2 > r) {
vis[a[t1].v] += a[t1].type == 1 ? 1 : (a[t1].type == 2 ? -1 : 0);
b[i] = a[t1++];
} else {
if (a[t2].type == 3) {
ans[a[t2].id] += vis[a[t2].v];
}
b[i] = a[t2++];
}
}
for (int i = l; i < t1; i++) {
if (a[i].type == 1) vis[a[i].v]--;
if (a[i].type == 2) vis[a[i].v]++;
}
for (int i = l; i <= r; i++) a[i] = b[i];
}
int main() {
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a[i].type, &a[i].t, &a[i].v);
x[i] = a[i].v;
a[i].id = i;
}
sort(x + 1, x + m + 1);
int n = unique(x + 1, x + m + 1) - x - 1;
for (int i = 1; i <= m; i++)
a[i].v = lower_bound(x + 1, x + n + 1, a[i].v) - x;
cdq(1, m);
sort(a + 1, a + m + 1);
for (int i = 1; i <= m; i++)
if (a[i].type == 3) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e9 + 7;
long long pow(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = ((res) * (x));
res %= N;
y = y >> 1;
x = ((x) * (x));
}
return res;
}
long long pow(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void solve() {
long long n;
cin >> n;
long long ans = 0;
while (n > 1) {
n /= 2;
ans++;
}
cout << ans + 1;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int K, Q;
cin >> K >> Q;
vector<int> D(K);
for(int i=0; i<K; i++) scanf("%d", &D[i]);
while(Q--){
int N, X, M;
scanf("%d %d %d", &N, &X, &M);
N--;
X %= M;
int L = N/K, R = N%K;
int64_t sum = X;
for(int i=0; i<K; i++){
int64_t d = D[i] % M;
if(d == 0) d = M;
sum += (i<R ? L+1 : L)*d;
}
int ans = N-sum/M;
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200003;
int arr[N];
int n;
void upd(int x) {
for (; x <= n; x += (x & (-x))) arr[x]++;
}
int qry(int x) {
int ans = 0;
for (; x; x -= (x & (-x))) ans += arr[x];
return ans;
}
struct yxh {
int x, id;
bool operator<(const yxh s) const {
if (x < s.x) return 1;
if (x > s.x) return 0;
if (id < s.id) return 1;
if (id > s.id) return 0;
return 0;
}
} a[N];
int ans[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].x;
a[i].id = i;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
int x = a[i].id;
for (int p = 1; (x - 1) * p + 2 <= n && p < n; p++) {
ans[p] += qry(min(p * x + 1, n)) - qry((x - 1) * p + 1);
}
upd(x);
}
for (int i = 1; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
| 6 |
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
int n,m;
int d[101][2];
int inf = 1111111111;
vector<pair<int,int> > g[101][2];
void dijkstra(int s){
priority_queue<pair<pair<int,int>,int>,vector<pair<pair<int,int>,int> >,greater<pair<pair<int,int>,int> > >que;
fill((int *)d,(int *)d+101*2,inf);
d[s][0] = 0;
que.push(make_pair(make_pair(0,s),0));
while(!que.empty()){
pair<pair<int,int>,int> p = que.top();que.pop();
int v = (p.first).second;
for(int i = 0;i<g[v][0].size();i++){
pair<int,int> e = g[v][0][i];
if(d[e.first][p.second] > d[v][p.second] + e.second){
d[e.first][p.second] = d[v][p.second] + e.second;
que.push(make_pair(make_pair(d[e.first][p.second],e.first),p.second));
}
}
//?????¶???
//e.second???0
for(int i = 0;p.second != 1 && i<g[v][1].size();i++){
pair<int,int> e = g[v][1][i];
if(e.second == 0 && p.second != 1 && d[e.first][p.second+1] > d[v][p.second] + e.second){
d[e.first][p.second+1] = d[v][p.second] + e.second;
que.push(make_pair(make_pair(d[e.first][p.second+1],e.first),p.second+1));
}
}
}
}
int main(){
while(cin>>n>>m){
if(n==0&&m==0)
break;
for(int i = 0;i<n;i++)
for(int j = 0;j<2;j++)
g[i][j].clear();
for(int i = 0;i<m;i++){
int a,b,c;
cin>>a>>b>>c;
a--;b--;
g[a][0].push_back(make_pair(b,c));
g[b][0].push_back(make_pair(a,c));
}
for(int i = 0;i<n;i++){
for(int j = 0,e=g[i][0].size();j<e;j++){
pair<int,int> tmp = g[i][0][j];
for(int k = 0;k<g[tmp.first][0].size();k++){
pair<int,int>t = g[tmp.first][0][k];
if(t.second==0)
continue;
g[i][1].push_back(make_pair(t.first,0));
}
}
}
dijkstra(0);
int ans = min(d[n-1][0],d[n-1][1]);
/*
for(int i = 0;i<n;i++){
for(int j = 0;j<2;j++){
cout<<d[i][j]<<" ";
}
cout<<endl;
}
*/
cout<<ans<<endl;
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.