solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
int n, i;
long long f(long long t[]) {
long long ans = t[0];
for (i = 1; i < n; i++) {
ans = (ans | t[i]);
}
return ans;
}
int main() {
long long a[1001], b[1001];
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%I64d", &a[i]);
for (i = 0; i < n; i++) scanf("%I64d", &b[i]);
printf("%I64d", f(a) + f(b));
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef pair<int,int>P;
typedef pair<int,P>P2;
int N,T,x[200009],n;
map<int,int>a[200009];
set<string>st;
vector<P2>v[200009];
string start,goal,str[200009];
map<int,string> s[200009];
P dis[200099];
int main(){
cin>>N>>T;
cin>>start>>goal;
st.insert(start);
st.insert(goal);
r(i,N){
cin>>x[i];
r(j,x[i]){
cin>>s[i][j];
str[n+j]=s[i][j];
a[i][j]=n+j;
st.insert(s[i][j]);
}
r(j,x[i]-1){
int y;
cin>>y;
v[n+j].push_back(P2(n+j+1,P(y,0)));
v[n+j+1].push_back(P2(n+j,P(y,0)));
}
n+=x[i];
}
map<string,int>M;
for(set<string>::iterator it=st.begin();it!=st.end();it++){
string x=*it;
str[n]=x;
M[x]=n++;
}
r(i,N){
r(j,x[i]){
int y=M[s[i][j]];
v[a[i][j]].push_back(P2(y,P(T,1)));
v[y].push_back(P2(a[i][j],P(0,0)));
}
}
priority_queue<P2,vector<P2>,greater<P2> >q;
r(i,200099)dis[i]=P(1e9,1e9);
r(i,n-st.size()){
if(str[i]==start){
q.push(P2(0,P(0,i)));
dis[i]=P(0,0);
}
}
while(!q.empty()){
P2 p=q.top();q.pop();
int now=p.second.second;
int cost=p.first;
int nori=p.second.first;
if(dis[now]<P(cost,nori))continue;
r(i,v[now].size()){
int nex=v[now][i].first;
int ncost=v[now][i].second.first+cost;
int nnori=v[now][i].second.second+nori;
P NEX=P(ncost,nnori);
if(NEX<dis[nex]){
dis[nex]=NEX;
q.push(P2(ncost,P(nnori,nex)));
}
}
}
P ans=P(1e9,1e9);
r(i,n-st.size()){
if(str[i]==goal){
ans=min(ans,dis[i]);
}
}
if(ans==P(1e9,1e9))cout<<-1<<endl;
else cout<<ans.first<<' '<<ans.second<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p) {
long long ans = 1;
x = x % p;
if (x == 0) {
return 0;
}
while (y > 0) {
if (y & 1) {
ans = (ans * x) % p;
}
y = y >> 1;
x = (x * x) % p;
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, l, r;
cin >> n >> m >> l >> r;
long long curr = n * m;
long long val = r - l + 1;
long long ans = power(val, curr, 998244353);
if (curr % 2) {
cout << ans << "\n";
return 0;
}
if (val % 2) {
ans++;
}
long long now = (998244353 + 1) / 2;
ans *= now;
ans %= 998244353;
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long m = 1000000007;
const double pi = acos(-1);
const int N = 5e2 + 10;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, a, b;
cin >> n >> a >> b;
for (long long i = 0; i < n / a + 1; i++)
if ((n - a * i) % b == 0)
return cout << "YES" << '\n' << i << " " << (n - a * i) / b, 0;
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int d[1050];
int n, m, h;
double lg[1050 * 1050];
double getlgc(int n, int m) { return lg[n] - lg[m] - lg[n - m]; }
int main() {
while (scanf("%d%d%d", &n, &m, &h) != EOF) {
int sum;
sum = 0;
for (int i = 1; i <= m; i++) {
scanf("%d", &d[i]);
sum += d[i];
}
if (sum < n) {
printf("-1\n");
continue;
}
int tsum;
tsum = sum;
lg[0] = 0;
for (int i = 1; i <= tsum; i++) lg[i] = lg[i - 1] + log((double)(i));
sum -= d[h];
if (sum < n - 1) {
printf("1.0\n");
continue;
}
double ans;
ans = 0.0;
ans = getlgc(sum, n - 1) - getlgc(tsum - 1, n - 1);
ans = exp(ans);
ans = 1.0 - ans;
printf("%lf\n", ans);
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
const int N = 5005, M = 202, LG = 14;
int n, m, B[M][N], Log[N];
long long Mx, A[N], dp[N][N];
pair < int , int > MX[LG][N];
inline int RMQ(int l, int r)
{
int &lg = Log[r - l];
return (max(MX[lg][l], MX[lg][r - (1 << lg)]).second);
}
void Solve(int l, int r)
{
if (r < l) return ;
int i = RMQ(l, r + 1);
dp[l][i] += MX[0][i].first;
dp[i + 1][i] -= MX[0][i].first;
dp[l][r + 1] -= MX[0][i].first;
dp[i + 1][r + 1] += MX[0][i].first;
Solve(l, i - 1); Solve(i + 1, r);
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; i++)
scanf("%d", &A[i]), A[i] += A[i - 1];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
scanf("%d", &B[j][i]);
for (int i = 2; i < N; i++)
Log[i] = Log[i >> 1] + 1;
for (int j = 1; j <= m; j++)
{
for (int i = 1; i <= n; i++)
MX[0][i] = {B[j][i], i};
for (int h = 1; h < LG; h++)
for (int i = 1; i + (1 << h) <= n + 1; i++)
MX[h][i] = max(MX[h - 1][i], MX[h - 1][i + (1 << h - 1)]);
Solve(1, n);
}
for (int i = 1; i < N; i++)
for (int j = 1; j < N; j++)
dp[i][j] += dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1];
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
Mx = max(Mx, dp[i][j] - A[j] + A[i]);
return !printf("%lld", Mx);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long int n,ans=0;
cin >> n;
long long int a[300010];
for (int i=0;i<3*n;i++)
cin >> a[i];
sort(a,a+3*n,greater<int>());
for (int i=0;i<n;i++)ans+=a[1+2*i];
cout << ans <<endl;
}
| 0 |
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int C, N;
cin >> C >> N;
vector<string> S(N);
for (int i = 0; i < N; ++i) {
cin >> S[i];
}
function<bool(int, int)> judge = [&](int i, int j) {
if (S[i][j] == S[N - i - 1][j] && S[i][j] == S[i][N - j - 1] && S[i][j] == S[N - i - 1][N - j - 1]) return true;
return false;
};
int cnt = 0;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
int x = min(i, N - i - 1), y = min(j, N - j - 1);
if (x == i && y == j) {
if (!judge(x, y)) ++cnt;
}
}
}
int ans = 0;
if (cnt == 0) ++ans;
for (int i = 1; i < C; ++i) {
int D;
cin >> D;
for (int j = 0; j < D; ++j) {
int x, y;
cin >> x >> y; --x, --y;
int tx = min(x, N - x - 1), ty = min(y, N - y - 1);
if (!judge(tx, ty)) --cnt;
S[x][y] = (S[x][y] == '0' ? '1' : '0');
if (!judge(tx, ty)) ++cnt;
}
if (cnt == 0) ++ans;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long n, m, l, r;
set<pair<int, int> > s;
vector<int> dv[maxn];
inline void Add(int i) {
for (auto A : dv[i]) s.insert({A, i});
}
inline void Del(int i) {
for (auto A : dv[i]) s.erase({A, i});
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> l >> r;
for (int i = 1; i <= max(n, m); i++)
for (int j = i; j <= max(n, m); j += i) dv[j].push_back(i);
long long L, R;
L = m + 1, R = m;
for (int x1 = 1; x1 <= n; x1++) {
while ((L - 1) * x1 >= l) Add(--L);
while (R * x1 > r) Del(R--);
bool e = 0;
for (auto i : dv[x1]) {
if (e) break;
auto it = s.upper_bound({i + 1, 0});
if (it == s.end()) continue;
long long y1 = (*it).second;
long long y2 = 1LL * i * (*it).second / (*it).first;
long long x2 = 1LL * x1 * y1 / y2;
if (x2 > n) continue;
e = 1;
cout << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2;
}
if (!e) cout << -1;
cout << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, LG = 20, INF = 1e9 + 7;
long long par[N][LG + 2], cnt[N], n, m, k, h[N], highest[N], cutedge[N];
vector<int> adj[N];
bool mark[N];
void DFS(int v, int parent, int t) {
mark[v] = 1;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (mark[u]) {
if (u != parent && t) highest[v] = min(h[u], highest[v]);
continue;
}
if (t) {
h[u] = h[v] + 1;
par[u][0] = v;
} else
cutedge[u] += cutedge[v];
DFS(u, v, t);
if (t) highest[v] = min(highest[v], highest[u]);
}
if (highest[v] >= h[v] && t) cutedge[v]++;
}
long long LCA(int a, int b) {
if (h[a] < h[b]) swap(a, b);
for (int i = LG; i >= 0; i--)
if (h[par[a][i]] >= h[b]) a = par[a][i];
if (a == b) return a;
for (int i = LG; i >= 0; i--)
if (par[a][i] != par[b][i]) a = par[a][i], b = par[b][i];
return par[a][0];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
memset(highest, INF, sizeof highest);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
h[0] = -1;
DFS(1, 0, 1);
memset(mark, 0, sizeof mark);
DFS(1, 0, 0);
for (int j = 1; j <= LG; j++)
for (int i = 1; i <= n; i++) par[i][j] = par[par[i][j - 1]][j - 1];
cin >> k;
while (k--) {
int x, y;
cin >> x >> y;
int lca = LCA(x, y);
cout << cutedge[x] + cutedge[y] - 2 * cutedge[lca] << endl;
}
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define gc getchar_unlocked
#define ll long long
#define PI 3.1415926535897932384626
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define fast ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
const int M=1000000007;
void solution()
{
int i, j, k, n, m;
cin>>n;
vector<string>s;
for(int i=0;i<3;i++)
{
string str;
cin>>str;
s.pb(str);
}
vector<string>one,zero;
for(int i=0;i<3;i++)
{
int cnt=0;
for(char c:s[i]) if(c=='1') cnt++;
if(cnt>=n) one.pb(s[i]);
else zero.pb(s[i]);
}
if(one.size()>=2)
{
string str="";
string ans="";
for(int i=0;i<n;i++) str+="1";
i=0,j=0,k=0;
while(i<2*n && j<2*n && k<n)
{
while(i<2*n && one[0][i]=='0') ans+="0",i++;
while(j<2*n && one[1][j]=='0') ans+="0",j++;
if(i==2*n || j==2*n) break;
ans+=str[k];
k++;
i++;
j++;
}
while(i<2*n) ans+=one[0][i],i++;
while(j<2*n) ans+=one[1][j],j++;
cout<<ans<<'\n';
}
else
{
string str="";
string ans="";
for(int i=0;i<n;i++) str+="0";
i=0,j=0,k=0;
while(i<2*n && j<2*n && k<n)
{
while(i<2*n && zero[0][i]=='1') ans+="1",i++;
while(j<2*n && zero[1][j]=='1') ans+="1",j++;
if(i==2*n || j==2*n) break;
ans+=str[k];
k++;
i++;
j++;
}
while(i<2*n) ans+=zero[0][i],i++;
while(j<2*n) ans+=zero[1][j],j++;
cout<<ans<<'\n';
}
}
int main()
{
int t=1;
cin>>t;
while(t--)
{
solution();
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
long long mod = 1000000009;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool is_vowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y')
return 1;
return 0;
}
double getDistance(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
long long extended_euclidean(long long a, long long b, long long &x,
long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long g = extended_euclidean(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
long long power(long long base, long long p) {
if (p == 1) return base;
if (!p) return 1ll;
long long ret = power(base, p / 2);
ret *= ret;
ret %= mod;
if (p & 1) ret *= base;
return ret % mod;
}
map<int, int> sol;
int a[200005];
int main() {
int n;
cin >> n;
int mx = 0;
for (int i = (1); i <= (n); ++i) {
scanf("%d", &a[i]);
if (mx == 0) {
mx = 1;
}
sol[a[i]] = max(sol[a[i]], 1 + sol[a[i] - 1]);
mx = max(mx, sol[a[i]]);
}
vector<int> v;
cout << mx << endl;
for (int i = (n); i >= (1); --i) {
if (sol[a[i]] == mx) {
v.push_back(i);
a[i]--;
for (int j = (i - 1); j >= (1); --j) {
if (a[j] == a[i]) {
v.push_back(j);
a[i]--;
}
}
reverse(v.begin(), v.end());
for (int j = (0); j <= ((int)v.size() - 1); ++j) cout << v[j] << ' ';
return 0;
}
}
return 0;
}
| 6 |
#include <iostream>
#include <cstdio>
using namespace std;
int map[50][50];
int w, h;
void dfs(int x, int y){
map[y][x] = 0;
for(int i = -1; i <= 1; i++){
for(int j = -1; j <= 1; j++){
int nx = x + i, ny = y + j;
if(nx >= 0 && nx < w && ny >= 0 && ny < h && map[ny][nx] == 1) dfs(nx, ny);
}
}
return;
}
int main(void){
int cnt;
while(true){
cin >> w >> h;
if(!w && !h) break;
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
cin >> map[i][j];
}
}
cnt = 0;
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
if(map[i][j] == 1){
dfs(j, i);
cnt++;
}
}
}
cout << cnt << endl;
}
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main() {
int q1, b, c1, c2, q2;
while (cin >> q1) {
if (q1 == 0) {
break;
}
cin >> b >> c1 >> c2 >> q2;
if (b < c1) {
cout << "NA" << endl;
} else {
int counter = 0;
while (q2 > 0 && b >= c1) {
b -= c1;
q1--;
q2--;
counter++;
}
int counter2 = 0;
while (b >= c2) {
b -= c2;
q1--;
counter2++;
}
if (q1 > 0) {
while (q1 > 0) {
counter--;
b += c1;
q1++;
if (counter == 0) {
break;
}
while (b >= c2) {
b -= c2;
q1--;
counter2++;
}
}
if (counter > 0) {
cout << counter << " " << counter2 << endl;
} else {
cout << "NA" << endl;
}
} else {
cout << counter << " " << counter2 << endl;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const bool debug = true;
const long long INFL = LLONG_MAX;
int A, B, N, M, H, S[1010];
long double memo[100100][102];
bool was[100100][102];
long double dp(int b, int n) {
int a = A;
if (a + b < n) return 0;
if (b < n) return 0;
if (n == 0) return 1;
if (a < 0 || b < 0 || n < 0) return 0;
if (was[b][n]) return memo[b][n];
long double x = (long double)n / (a + b);
memo[b][n] = x * dp(b - 1, n - 1) + (1 - x) * dp(b - 1, n);
was[b][n] = 1;
return memo[b][n];
}
int main() {
ios_base::sync_with_stdio(0);
cout.precision(15);
cout << fixed;
cin >> N >> M >> H;
for (int(i) = 1; (i) <= (M); (i)++) cin >> S[i];
S[H]--;
for (int(i) = 1; (i) <= (M); (i)++)
if (i == H)
A = S[i];
else
B += S[i];
N--;
if (A + B < N) {
cout << -1 << '\n';
} else {
cout << (1 - dp(B, N)) << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct state {
int x, y, s;
state(int _x, int _y, int _s) {
x = _x;
y = _y;
s = _s;
};
};
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
char a[22][22];
int v[22];
int px[22], py[22];
int d[22][22][1 << 8];
struct cmp {
bool operator()(const state &a, const state &b) {
if (d[a.x][a.y][a.s] != d[b.x][b.y][b.s])
return d[a.x][a.y][a.s] < d[b.x][b.y][b.s];
if (a.x != b.x) return a.x < b.x;
if (a.y != b.y) return a.y < b.y;
return a.s < b.s;
}
};
set<state, cmp> S;
int main(void) {
int n, m;
scanf("%d %d", &n, &m);
int t = 0, p = 0;
int sx, sy;
for (int i = 0; i < (n); ++i) {
scanf("%s", a[i]);
for (int j = 0; j < (m); ++j) {
if (isdigit(a[i][j]) || a[i][j] == 'B') px[p] = i, py[p] = j, p++;
if (isdigit(a[i][j])) t = max(t, a[i][j] - '0');
if (a[i][j] == 'S') sx = i, sy = j, a[i][j] = '.';
}
}
for (int i = 0; i < (t); ++i) scanf("%d", v + i);
memset(d, 63, sizeof(d));
d[sx][sy][0] = 0;
S.insert(state(sx, sy, 0));
int ans = 0;
while (S.size()) {
state s = *S.begin();
S.erase(S.begin());
int r = d[s.x][s.y][s.s];
if (s.x == sx && s.y == sy) {
int sum = 0;
for (int i = 0; i < (p); ++i)
if (s.s & (1 << i)) {
if (a[px[i]][py[i]] == 'B') {
sum = -1;
break;
}
sum += v[a[px[i]][py[i]] - '1'];
}
ans = max(ans, sum - r);
}
for (int dd = 0; dd < (4); ++dd) {
int x = s.x + dx[dd], y = s.y + dy[dd], ss = s.s;
if (x < 0 || x >= n || y < 0 || y >= m || a[x][y] != '.') continue;
if (y != s.y)
for (int i = 0; i < (p); ++i)
if (py[i] == max(y, s.y) && px[i] < x) ss ^= (1 << i);
if (r + 1 < d[x][y][ss]) {
S.erase(state(x, y, ss));
d[x][y][ss] = r + 1;
S.insert(state(x, y, ss));
}
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
string but[10]={"",".,!? ","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
for(int x=0;x<n;x++){
string a;
cin>>a;
string ans="";
int b=0,c=0;
for(int i=0;i<a.size();i++){
if(a[i]=='0'){
if(b!=0){
int num=(c+but[b].size()-1)%but[b].size();
ans.push_back(but[b][num]);
b=0,c=0;
}
}
else{
b=a[i]-'0';
c++;
}
}
cout<<ans<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e6 + 42;
vector<string> ans[nmax];
int n;
string in;
int depth = 0;
pair<string, int> inp[nmax];
bool vis[nmax];
void dfs(int node, int level) {
if (inp[node].second == 0) {
vis[node] = 1;
ans[level].push_back(inp[node].first);
depth = max(depth, level);
return;
}
int where = node + 1;
for (int now = 0; now < inp[node].second; now++) {
while (vis[where] == 1) where++;
dfs(where, level + 1);
}
vis[node] = 1;
ans[level].push_back(inp[node].first);
}
int main() {
string in;
getline(cin, in);
in = in + ",";
n = in.size();
int i = 0, sz = 0;
while (i < n) {
int j = i;
while (('a' <= in[j] && in[j] <= 'z') || ('A' <= in[j] && in[j] <= 'Z'))
j++;
inp[sz].first = in.substr(i, j - i);
j++;
int now = 0;
while ('0' <= in[j] && in[j] <= '9') now = now * 10 + (in[j] - '0'), j++;
j++;
inp[sz].second = now;
sz++;
i = j;
}
for (i = 0; i < sz; i++)
if (vis[i] == 0) {
dfs(i, 1);
}
cout << depth << endl;
for (i = 1; i <= depth; i++) {
int lim = ans[i].size();
for (int j = 0; j < lim; j++) cout << ans[i][j] << " ";
cout << endl;
}
return 0;
}
| 5 |
#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int main(){
while(1){
int m,nmin,nmax; cin >> m >> nmin >> nmax;
if (m + nmin + nmax == 0) break;
int dis = 0;
int max = 0;
int maxi = 0;
int pre_p = 0;
for (int i = 1; i <= m; i++){
int p1; cin >> p1;
if (nmin < i and i <= nmax + 1){
dis = pre_p - p1;
if (max <= dis){
max = dis;
maxi = i;
}
}
pre_p = p1;
}
cout << maxi - 1 << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long int i, n, m, x, y, z, j, k, l, mn = LLONG_MAX, mx = 0, c, a[100005],
r, s, cnt = 0, sum = 0;
string str;
char ch;
vector<vector<long long int>> g;
bool v[1000];
void swap(int *xp, int *yp) {
int temp = *xp;
*xp = *yp;
*yp = temp;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
long long int max = LLONG_MIN, smax = LLONG_MIN;
for (i = 1; i <= n; i++) {
cin >> x;
a[i] = a[i - 1] + x;
}
for (i = 1; i <= m; i++) {
cin >> l >> r;
x = a[r] - a[l - 1];
if (x > 0) sum += x;
}
cout << sum << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int ans;
int n, m, d;
int c[maxn];
int t[maxn];
int cnt[maxn];
int num[maxn];
int bois[maxn];
bool bad[maxn * 20];
void in();
void solve();
void add();
void out();
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
in();
solve();
out();
}
void in() {
cin >> n >> m >> d;
for (int i = 0; i < m; i++) {
cin >> t[i];
for (int j = 0; j < t[i]; j++) {
int x;
cin >> x;
c[x - 1] = i;
}
}
}
void solve() {
for (int i = 0; i < d; i++) cnt[c[i]]++;
add();
for (int i = d; i < n; i++) {
cnt[c[i]]++;
cnt[c[i - d]]--;
add();
}
ans = m;
for (int i = (1 << m) - 1; i >= 0; i--) {
if (!bad[i])
ans = min(ans, __builtin_popcount(i));
else
for (int j = 0; j < m; j++)
if ((1 << j) & i) bad[i - (1 << j)] = 1;
}
}
void add() {
int mask = 0;
for (int i = 0; i < m; i++) {
if (!cnt[i]) {
mask += 1 << i;
bois[i]++;
}
}
bad[mask] = 1;
}
void out() { cout << ans; }
| 4 |
#define _USE_MATH_DEFINES
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <complex>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
#include <iterator>
using namespace std;
const int MOD = 1000000007;
int main()
{
int n, k;
cin >> n >> k;
vector<int> x(n);
for(int i=0; i<n; ++i)
cin >> x[i];
vector<vector<long long> > dp(n+1, vector<long long>(256, 0));
dp[0][0] = 1;
for(int i=0; i<n; ++i){
for(int a=n-1; a>=0; --a){
for(int b=0; b<256; ++b){
dp[a+1][b^x[i]] += dp[a][b] * (a + 1);
dp[a+1][b^x[i]] %= MOD;
}
}
}
int ans = 0;
for(int i=0; i<=n; ++i){
ans += dp[i][k];
ans %= MOD;
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 10;
typedef long long ll;
int N, P[MAX_N], V[MAX_N];
ll ans;
struct DSU {
int pa[MAX_N];
void init(int n) { for (int i = 1; i <= n; i++) pa[i] = i; }
int query(int x) { return pa[x] == x ? x : pa[x] = query(pa[x]); }
void merge(int a, int b) {
a = query(a); b = query(b);
pa[a] = b;
}
} dsu;
struct Group {
ll c0, c1;
int id;
Group() {}
Group(ll c0, ll c1, int id) : c0(c0), c1(c1), id(id) {}
bool operator<(const Group &rhs) const {
ll t = c1 * rhs.c0 - rhs.c1 * c0;
if (t != 0) return t < 0;
return id < rhs.id;
}
} groups[MAX_N];
int main() {
scanf("%d", &N);
for (int i = 2; i <= N; i++) scanf("%d", &P[i]);
for (int i = 1; i <= N; i++) scanf("%d", &V[i]);
dsu.init(N);
for (int i = 1; i <= N; i++) {
groups[i] = Group(V[i] == 0, V[i] == 1, i);
}
set<Group> st;
for (int i = 2; i <= N; i++) {
st.insert(groups[i]);
}
for (int i = 1; i < N; i++) {
Group x = *st.begin(), y = groups[dsu.query(P[x.id])];
st.erase(x);
if (y.id != 1) {
st.erase(y);
}
ans += y.c1 * x.c0;
groups[y.id] = Group(x.c0 + y.c0, x.c1 + y.c1, y.id);
dsu.merge(x.id, y.id);
if (y.id != 1) {
st.insert(groups[y.id]);
}
}
printf("%lld\n", ans);
}
| 0 |
#include <bits/stdc++.h>
/**
special:n-1相加不互质,n-1分开互质
数目<=20000,值<=30000
**/
int n;
int main()
{
scanf("%d",&n);
int n3=n/3;
int adjust=0;
if(n==3||n==6)
{
if(n==3)
printf("2 5 63\n");
else
printf("2 4 8 10 3 9\n");
return 0;
}
if(n3>5000)
n3=5000;
else
{
if(n%3==0)
n3-=2;
}
if((n-3*n3)%2==1)
adjust=1;
int X2=n3*3-adjust;
int X3=n-X2;
for(int i=1;i<=X2;i++)
printf("%d ",i*2);
for(int i=1;i<=X3;i++)
{
if(i==X3)
printf("%d\n",(2*i-1)*3);
else
printf("%d ",(2*i-1)*3);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cube(int a, int b) {
int o = a;
for (int i = 1; i < b; i++) {
o *= a;
}
return o;
}
void testing_ifs() {
bool isMale;
string a, b;
bool isTall;
int i = 0;
bool repeat = true;
while (repeat == true) {
while (a != "yes" && a != "no") {
cout << "are you male? yes/no " << i << '\n';
cin >> a;
i = i + 1;
if (a == "yes") {
isMale = true;
} else
isMale = false;
}
while (b != "yes" && b != "no") {
if (isMale) {
cout << "are you tall? yes/no\n";
cin >> b;
if (b == "yes") {
isTall = true;
} else
isTall = false;
} else {
b = "no";
}
}
if (isMale && isTall) {
cout << "You Are alpha Male\n";
}
if (isMale && !isTall) {
cout << "You Are a short Male\n";
}
if (!isMale) cout << "You are beyta\n";
cout << "do you want to repeat the program? Yes/No\n";
string repeat;
cin >> repeat;
if (repeat == "no")
break;
else {
a = "aaaaa";
b = "bbbbb";
}
}
}
int getMax(int num1, int num2, int num3) {
int result;
if (num1 > num2 && num1 > num3) {
result = num1;
} else if (num2 > num1 && num2 > num3) {
result = num2;
} else
result = num3;
return result;
}
int stones() {
int output = 0;
int n;
string s;
cin >> n;
cin >> s;
int j = 0;
char x = s[0];
for (int i = 1; i < (s.length()); i++) {
if (x == s[i]) {
output++;
}
x = s[i];
}
cout << output;
return 0;
}
int weather_this_DOESNT_WORK() {
int outcome = 0;
int n;
cin >> n;
vector<int> temps(n);
vector<int> temps_from_input(n);
vector<int>::iterator it, it2;
int j = 0;
int temps_iter = 0;
for (it = temps.begin(); it != temps.end(); it++) {
cin >> *it;
}
for (it = temps.begin(); it != temps.end(); it++, temps_iter++) {
temps_from_input.push_back(*it);
}
for (int i = 0; i < n - 1; i++) {
if (temps[i] != 0) {
if (temps[i] > 0 && temps[i + 1] < 0) {
if (i == 0) {
outcome++;
temps[i] = -1;
}
if (i == (n - 2) && (temps[i + 1] < 0)) {
cout << "you lose1 " << i;
outcome++;
break;
} else if (temps[i - 1] < 0) {
outcome++;
}
} else if (temps[i] < 0 && temps[i + 1] > 0) {
if (i == 0) {
temps[i] = 1;
outcome++;
}
if (i == (n - 2) && (temps[i + 1] > 0)) {
cout << "you lose2 " << i;
outcome++;
} else if (temps[i - 1] > 0) {
outcome++;
}
}
} else {
outcome++;
}
}
cout << " " << outcome;
return 0;
}
int sets() {
string name;
set<char> letters;
cin >> name;
for (int i = 0; i < name.length(); i++) {
letters.insert(name[i]);
}
if (letters.size() % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
return 0;
}
int nanners() {
int k;
int n;
int w;
int tot_cost = 0;
cin >> k >> n >> w;
for (int i = 1; i <= w; i++) {
tot_cost = tot_cost + k * i;
}
if (tot_cost - n > 0)
cout << tot_cost - n;
else
cout << 0;
return 0;
}
int bears() {
int a, b;
cin >> a >> b;
int i = 0;
for (i = 0; a <= b; i++) {
a = a * 3;
b = b * 2;
}
cout << i;
return 0;
}
int tram() {
int n, a, b, max = 0, curr = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
curr = curr - a + b;
max = std::max(max, curr);
}
cout << max;
return 0;
}
int wierd_math() {
int a, b;
cin >> a >> b;
for (int i = 0; i < b; i++)
if (a % 10 == 0) {
a = a / 10;
} else {
a = a - 1;
}
cout << a;
return 0;
}
int main() {
wierd_math();
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn = 50 + 3;
int mat[maxn][maxn],n,m,q;
int on[maxn][maxn];
int off[maxn][maxn];
int t[maxn][maxn];
int ptr[maxn][maxn];
vector<int>PPP[maxn][maxn];
char s[maxn][maxn];
struct node
{
int x,y;
};
node mis[1200];
vector<node> Q;
vector<node> P;
int Flag=0;
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int vis[maxn][maxn];
void dfs(int x,int y,int xx,int yy)
{
if(Flag)return;
if(x==xx&&y==yy)
{
int stary = 0;
for(int i=1;i<P.size();i++)
Q.push_back(P[i]);
Flag=1;
return;
}
for(int i=0;i<4;i++)
{
int xxx = x+dx[i];
int yyy = y+dy[i];
if(xxx<=0||xxx>n)continue;
if(yyy<=0||yyy>m)continue;
if(vis[xxx][yyy])continue;
if(s[xxx][yyy]=='#')continue;
node ttt;ttt.x=xxx;ttt.y=yyy;
P.push_back(ttt);
vis[xxx][yyy]=1;
dfs(xxx,yyy,xx,yy);
P.pop_back();
}
}
int main()
{
//freopen("in.txt","r",stdin);
scanf("%d%d%d",&n,&m,&q);
for(int i=1;i<=n;i++)
scanf("%s",s[i]+1);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
scanf("%d",&t[i][j]);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
scanf("%d",&on[i][j]);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
scanf("%d",&off[i][j]);
for(int i=1;i<=q;i++)
{
scanf("%d%d",&mis[i].x,&mis[i].y);
mis[i].x++;mis[i].y++;
}
Q.push_back(mis[1]);
for(int i=1;i<q;i++)
{
memset(vis,0,sizeof(vis));
Flag=0;
P.clear();
vis[mis[i].x][mis[i].y]=1;
node k;k.x=mis[i].x,k.y=mis[i].y;
P.push_back(k);
dfs(mis[i].x,mis[i].y,mis[i+1].x,mis[i+1].y);
}
for(int i = 0 ; i < Q.size() ; ++ i)
{
node cur = Q[i];
int x = cur.x , y = cur.y;
PPP[x][y].push_back(i);
}
int ans = 0;
for(int i = 1 ; i <= n ; ++ i)
for(int j = 1 ; j <= m ; ++ j)
if(PPP[i][j].size() != 0)
{
ans += on[i][j]; ans += off[i][j];
for(int z = 0 ; z < PPP[i][j].size() - 1 ; ++ z)
{
int dis = PPP[i][j][z+1] - PPP[i][j][z];
ans += min(dis * t[i][j] , off[i][j] + on[i][j]);
}
}
printf("%d\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9;
const int N = 15;
int g[N][N];
void dfs(int i, int j, int pi, int pj) {
int u, v;
if (g[i + pi][j + pj] > g[i][j]) {
g[i + pi][j + pj] = g[i][j];
dfs(i + pi, j + pj, pi, pj);
}
for (u = -1; u < 2; ++u)
for (v = -1; v < 2; ++v)
if (((((u) > 0) ? ((u)) : (-(u))) + (((v) > 0) ? ((v)) : (-(v))) == 2) &&
(g[i + u][j + v] > g[i][j] + 1)) {
g[i + u][j + v] = g[i][j] + 1;
dfs(i + u, j + v, u, v);
}
}
int main() {
int x1, y1, x2, y2, i, j, an;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
printf("%d ", bool(x2 - x1) + bool(y2 - y1));
if (((x1 + y1) & 1) != ((x2 + y2) & 1))
printf("0 ");
else if ((((x2 - x1) > 0) ? ((x2 - x1)) : (-(x2 - x1))) ==
(((y2 - y1) > 0) ? ((y2 - y1)) : (-(y2 - y1))))
printf("1 ");
else
printf("2 ");
an = 0;
while ((x1 != x2) || (y1 != y2)) {
++an;
if (x1 < x2)
++x1;
else if (x1 > x2)
--x1;
if (y1 < y2)
++y1;
else if (y1 > y2)
--y1;
}
printf("%d\n", an);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007, M = 3e5 + 7;
long long powe(long long x, long long y) {
x = x % mod;
long long ans = 1;
while (y > 0) {
if (y & 1) {
ans = (1ll * x * ans) % mod;
}
y >>= 1;
x = (1ll * x * x) % mod;
}
return ans;
}
stack<int> moves, fin;
vector<int> ch;
int a, b, c, m, l;
void move() {
if (c == m) {
while (moves.size()) {
fin.push(moves.top());
moves.pop();
}
cout << "YES\n";
while (fin.size()) {
cout << fin.top() << " ";
fin.pop();
}
exit(0);
}
int x = upper_bound(ch.begin(), ch.end(), a) - ch.begin();
if (x == l) return;
int pb = b;
for (; x < l; x++) {
if (ch[x] == b) continue;
b = ch[x];
a = b - a;
c++;
moves.push(b);
move();
moves.pop();
c--;
a = b - a;
b = pb;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string inp;
cin >> inp;
cin >> m;
for (int i = 0; i < 10; i++) {
if (inp[i] == '1') ch.push_back(i + 1);
}
l = ch.size();
move();
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
inline void multiply(long long mat1[][2], long long mat2[][2]) {
long long res[2][2];
long long i, j, k;
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
res[i][j] = 0;
for (k = 0; k < 2; k++)
res[i][j] = (res[i][j] + (mat1[i][k] * mat2[k][j])) % mod;
}
}
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) mat1[i][j] = res[i][j];
}
}
inline long long moduloexp(long long l, long long p) {
long long res = 1;
while (p > 0) {
if (p % 2 == 1) {
res *= l;
res %= mod;
}
p /= 2;
l = (l * l) % mod;
}
return res;
}
inline long long modInverse(long long l, long long power, long long mod) {
l = moduloexp(l, power);
return moduloexp(l, mod - 2);
}
inline void fs(long long &number) {
bool negative = false;
register long long c;
number = 0;
c = getchar();
if (c == '-') {
negative = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
if (negative) number *= -1;
}
int main() {
string p;
int i, j, t = 0;
cin >> p;
string s[6];
s[0] = "ABC";
s[1] = "ACB";
s[2] = "BAC";
s[3] = "BCA";
s[4] = "CAB";
s[5] = "CBA";
for (i = 0; i < 6; i++) {
size_t found = p.find(s[i]);
if (found != std::string::npos) {
t = 1;
cout << "Yes";
break;
}
}
if (t == 0) cout << "No";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double dis(int x1, int y1, int x2, int y2) {
return sqrt((powl((x1 - x2), 2)) + (powl((y1 - y2), 2)));
}
bool com(pair<int, int> x1, pair<int, int> x2) {
if (x1.first == x2.first)
return x1.second < x2.second;
else
return x1.first < x2.first;
}
const int mod = 1000000007;
long long int modPow(long long int a, long long int x, long long int p) {
long long int res = 1;
while (x > 0) {
if (x & 1) res = (res * a) % p;
a = (a * a) % p;
x >>= 1;
}
return res;
}
long long int modInverse(long long int a, long long int p) {
return modPow(a, p - 2, p);
}
long long int c(long long int n, long long int k, long long int p) {
long long int numerator = 1;
int i;
for (i = 0; i < k; i++) numerator = (numerator * (n - i)) % p;
long long int denominator = 1;
for (i = 1; i <= k; i++) denominator = (denominator * i) % p;
long long int res = modInverse(denominator, p);
res = (res * numerator) % p;
return res;
}
bool com1(pair<int, int> x, pair<int, int> y) { return x.first > y.first; }
vector<pair<long long int, long long int> > v;
long long int SumPre[500005];
void bns(int s, long long int k) {
long long int l = v.size() - 1;
long long int ct = 0;
long long int s1 = s;
while (s < l) {
if (ct++ > 60) break;
int mid = (l + s + 1) >> 1;
if (v[s1].first * (mid - s1) - (SumPre[mid] - SumPre[s1]) <= k) {
v[s1].second = max(v[s1].second, mid - s1 + 1);
s = mid;
} else
l = mid - 1;
}
}
int main() {
int n, k;
long long int maxx = 0, index = 0;
cin >> n >> k;
for (int i = int(0); i <= int(n - 1); i++) {
int x;
cin >> x;
v.push_back(make_pair(x, 1));
}
sort(v.begin(), v.end(), com1);
SumPre[0] = v[0].first;
for (int i = int(1); i <= int(n - 1); i++)
SumPre[i] += v[i].first + SumPre[i - 1];
for (int i = int(0); i <= int(n - 1); i++) bns(i, k);
for (int i = int(0); i <= int(n - 1); i++) {
if (maxx < v[i].second) {
maxx = v[i].second;
index = i;
}
if (maxx == v[i].second && v[i].first < v[index].first) index = i;
}
cout << v[index].second << " " << v[index].first;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t, a, countL = 0, countR = 0;
int v[100001];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
v[a] = i;
}
cin >> t;
while (t--) {
cin >> a;
countL = countL + v[a] + 1;
countR = countR + (n - v[a]);
}
cout << countL << " " << countR;
}
| 2 |
#include <bits/stdc++.h>
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
const int Maxn = 500000;
const int Inf = 0x3f3f3f3f;
struct Segment_Tree_1 {
struct Segment_Node {
int lazy;
int val;
} seg[Maxn << 2 | 5];
void build(int root = 1, int left = -Maxn, int right = 0) {
if (left == right) {
seg[root].val = left;
return;
}
int mid = (left + right) >> 1;
build(root << 1, left, mid);
build(root << 1 | 1, mid + 1, right);
seg[root].val = max(seg[root << 1].val, seg[root << 1 | 1].val);
}
void update_tag(int root, int a) {
seg[root].lazy += a;
seg[root].val += a;
}
void push_down(int root) {
update_tag(root << 1, seg[root].lazy);
update_tag(root << 1 | 1, seg[root].lazy);
seg[root].lazy = 0;
}
void update(int l, int r, int a, int root = 1, int left = -Maxn,
int right = 0) {
if (l > right || r < left) {
return;
}
if (l <= left && r >= right) {
update_tag(root, a);
return;
}
push_down(root);
int mid = (left + right) >> 1;
update(l, r, a, root << 1, left, mid);
update(l, r, a, root << 1 | 1, mid + 1, right);
seg[root].val = max(seg[root << 1].val, seg[root << 1 | 1].val);
}
int query(int root = 1, int left = -Maxn, int right = 0) {
if (left == right) {
return left;
}
push_down(root);
int mid = (left + right) >> 1;
if (seg[root << 1].val >= 0) {
return query(root << 1, left, mid);
} else {
return query(root << 1 | 1, mid + 1, right);
}
}
} S;
struct Segment_Tree_2 {
struct Segment_Node {
int lazy;
int val;
} seg[Maxn << 3 | 5];
void build(int root = 1, int left = -Maxn, int right = Maxn) {
if (left == right) {
seg[root].val = left;
return;
}
int mid = (left + right) >> 1;
build(root << 1, left, mid);
build(root << 1 | 1, mid + 1, right);
seg[root].val = min(seg[root << 1].val, seg[root << 1 | 1].val);
}
void update_tag(int root, int a) {
seg[root].lazy += a;
seg[root].val += a;
}
void push_down(int root) {
update_tag(root << 1, seg[root].lazy);
update_tag(root << 1 | 1, seg[root].lazy);
seg[root].lazy = 0;
}
void update(int l, int r, int a, int root = 1, int left = -Maxn,
int right = Maxn) {
if (l > right || r < left) {
return;
}
if (l <= left && r >= right) {
update_tag(root, a);
return;
}
int mid = (left + right) >> 1;
push_down(root);
update(l, r, a, root << 1, left, mid);
update(l, r, a, root << 1 | 1, mid + 1, right);
seg[root].val = min(seg[root << 1].val, seg[root << 1 | 1].val);
}
int query(int l, int r, int root = 1, int left = -Maxn, int right = Maxn) {
if (l > right || r < left) {
return Inf;
}
if (l <= left && r >= right) {
return seg[root].val;
}
push_down(root);
int mid = (left + right) >> 1;
return min(query(l, r, root << 1, left, mid),
query(l, r, root << 1 | 1, mid + 1, right));
}
} T;
int n;
int main() {
S.build();
T.build();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x < 0) {
S.update(x, 0, 1);
}
T.update(-Maxn, x - 1, 1);
int pos = S.query();
printf("%d\n", T.query(pos, Maxn));
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
#define FOR(i, a, n) for(int i = (a); i < (n); i++)
#define REP(i, n) FOR(i, 0, (n))
#define ALL(a) (a.begin(), a.end())
typedef vector<int> vi;
int64_t h(const vector<vi> &t, int i, int p, vi &v) {
int64_t res = 1;
for (int c : t[i]) {
if (c == p) continue;
res += 1000000009 * h(t, c, i, v);
}
v[i] = res;
return res;
}
int main() {
int n;
cin>>n;
vector<vi> t(n);
REP(i,n-1) {
int a,b;
cin>>a>>b;
--a;
--b;
t[a].push_back(b);
t[b].push_back(a);
}
vi v(n);
h(t, 0, -1, v);
map<int64_t, int> m;
int64_t cnt = 0;
REP(i,n) {
cnt += m[v[i]];
++m[v[i]];
}
cout << cnt << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int vx[100111], vy[100111];
bool check(int x1, int y1, int x2, int y2, long long int x, long long int y) {
return (y - y2) * (x1 - x) - (y1 - y) * (x - x2) > 0;
}
long long int count(int x, int y) {
long long int ans = (long long int)n * (n - 1) * (n - 2) / 6;
int cur = 0;
int i = 1;
while (cur < n) {
while (check(vx[cur], vy[cur], vx[i % n], vy[i % n], x, y)) i++;
if (i % n == cur || !check(vx[(i + n - 1) % n], vy[(i + n - 1) % n],
vx[i % n], vy[i % n], x, y))
return 0;
ans -= ((long long int)i - cur - 2) * (i - cur - 1) / 2;
cur++;
}
return ans;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> vx[i] >> vy[i];
int t;
cin >> t;
while (t--) {
int x, y;
cin >> x >> y;
cout << count(x, y) << endl;
}
return 0;
}
| 5 |
#include <cstdio>
#include <cstring>
#define repu(i,x,y) for (int i=x; i<=y; ++i)
#define repd(i,x,y) for (int i=x; i>=y; --i)
using namespace std;
typedef long long LL;
int n,m,nxt[200100];
LL l,r,ans[26],sum[100][26],len[100];
char a[200100];
int calc(int m)
{
int x=m-n%m;
return (n+x)/m&1?x+m:x;
}
void solve(LL n,int w)
{
repd(i,m,0)
if (n>=len[i])
{
n-=len[i];
repu(j,0,25)
ans[j]+=w*sum[i][j];
}
repu(i,1,n)
ans[a[i]-'a']+=w;
}
int main()
{
scanf("%s%lld%lld",a+1,&l,&r),n=strlen(a+1)/2;
for (int i=2,j=0; i<=n; ++i)
{
for (; j && a[i]!=a[j+1]; j=nxt[j]);
nxt[i]=j+=a[i]==a[j+1];
}
len[m=1]=n,len[0]=n-nxt[n];
repu(i,1,n)
{
++sum[1][a[i]-'a'];
sum[0][a[i]-'a']+=i<=len[0];
}
while (len[m]<r)
{
++m,len[m]=len[m-1]+len[m-2];
repu(i,0,25)
sum[m][i]=sum[m-1][i]+sum[m-2][i];
}
solve(l-1,-1),solve(r,1);
repu(i,0,25)
printf("%lld ",ans[i]);
return 0;
} | 0 |
#include <bits/stdc++.h>
#define REP(i,n,N) for(int i=n;i<N;i++)
#define p(S) cout<<S<<endl
using namespace std;
int chizu[51][51];
void labeling(int y,int x,int w,int h){
chizu[y][x]=0;
REP(dy,-1,2){
REP(dx,-1,2){
if(0 <= y+dy && y+dy < h && 0 <= x+dx && x+dx < w){
if(chizu[y+dy][x+dx]){
labeling(y+dy,x+dx,w,h);
}
}
}
}
}
int main(){
int w,h;
while(cin>>w>>h&&w&&h){
int count=0;
REP(i,0,h){
REP(j,0,w){
cin>>chizu[i][j];
}
}
REP(i,0,h){
REP(j,0,w){
if(chizu[i][j]){
count++;
labeling(i,j,w,h);
}
}
}
p(count);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > graph;
vector<bool> visited;
long long ans;
long long *getArray(long long size) {
long long *arr = new long long[size];
for (long long i = 0; i < size; i++) arr[i] = 0;
return arr;
}
void merge(long long *childarr, long long *parentarr, long long lcadepth,
long long k) {
for (long long i = 0; i < k; i++) {
for (long long j = 0; j < k; j++) {
long long a = i + j;
long long b = 2 * lcadepth;
long long rem = ((a - b) % k + k) % k;
ans += (((k - rem) % k + k) % k) * childarr[i] * parentarr[j];
}
}
}
void updateArrSum(long long *arr, long long *childArr, long long k) {
for (long long i = 0; i < k; i++) {
arr[i] += childArr[i];
}
}
long long *dfs(long long current_node, long long &subtreesize, long long k,
long long n, long long depth) {
long long *arr = getArray(k);
long long subtreesize_local = 1;
arr[depth % k] = 1;
for (long long i = 0; i < graph[current_node].size(); i++) {
long long child = graph[current_node][i];
if (!visited[child]) {
visited[child] = true;
long long *childarr = dfs(child, subtreesize_local, k, n, depth + 1);
merge(childarr, arr, depth, k);
updateArrSum(arr, childarr, k);
}
}
subtreesize += subtreesize_local;
ans += subtreesize_local * (n - subtreesize_local);
return arr;
}
int main() {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n + 1; i++) {
graph.push_back(vector<long long>());
visited.push_back(false);
}
for (long long i = 0; i < n - 1; i++) {
long long a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
ans = 0;
visited[1] = true;
long long subtreesize = 0;
dfs(1, subtreesize, k, n, 0);
cout << ans / k;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char ch[610];
bitset<2100> now[2010], s[2010];
int n, pos[2010], num[2010];
void init(int id) {
int i, j, k, l = strlen(ch);
for (i = 0; i <= l - 1; i++) num[l - i] = ch[i] - '0';
for (i = 1; i <= 2010; i++) {
int res = 0, lastres;
for (j = l; j >= 1; j--) {
lastres = res;
res = res * 10 + num[j];
num[j] = (lastres * 10 + num[j]) / 2;
res %= 2;
}
now[id][i] = res;
while (l >= 1 && num[l] == 0) l--;
}
s[id][id] = 1;
}
int main() {
int i, j, k;
scanf("%d", &n);
memset(pos, -1, sizeof(pos));
for (i = 1; i <= n; i++) {
scanf("%s", ch);
init(i);
bool flag = true;
for (j = 1; j <= 2010; j++)
if (now[i][j]) {
if (pos[j] == -1) {
pos[j] = i;
flag = false;
break;
}
now[i] ^= now[pos[j]];
s[i] ^= s[pos[j]];
}
if (!flag)
printf("0\n");
else {
s[i][i] = 0;
printf("%d", s[i].count());
for (j = 1; j <= 2010; j++)
if (s[i][j]) printf(" %d", j - 1);
printf("\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2")
vector<long long int> ar[1000001];
long long int vis[1000001], dis[1000001], level[1000001];
const int MAX_SIZE = 1000001;
const int N = 2000010;
const int mod = 1e9 + 7;
vector<int> isprime(MAX_SIZE, true);
vector<int> prime;
vector<int> SPF(MAX_SIZE);
long long int fact[N];
void manipulated_seive(int N) {
isprime[0] = isprime[1] = false;
for (int i = 2; i < N; ++i) {
if (isprime[i]) {
prime.push_back(i);
SPF[i] = i;
}
for (int j = 0;
j < (int)prime.size() && i * prime[j] < N && prime[j] <= SPF[i]; ++j) {
isprime[i * prime[j]] = false;
SPF[i * prime[j]] = prime[j];
}
}
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
unordered_map<long long int, long long int> myp;
void primeFactors(long long int n) {
while (n % 2 == 0) {
myp[2]++;
n = n / 2;
}
for (long long int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
myp[i]++;
n = n / i;
}
}
if (n > 2) myp[n]++;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int findlcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
long long int power(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b % 2) res *= a;
a *= a;
b /= 2;
}
return res;
}
long long int power_mod(long long int a, long long int b, long long int p) {
long long int res = 1;
while (b) {
if (b % 2) {
res *= a;
res %= p;
}
a *= a;
a %= p;
b /= 2;
}
return res;
}
long long int mod_inverse(long long int x) {
return power_mod(x, mod - 2, mod);
}
long long int nCr(long long int n, long long int r) {
if (r == 0) return 1;
long long int a = fact[n];
long long int b = mod_inverse(fact[n - r]);
long long int c = mod_inverse(fact[r]);
return (((a * b) % mod) * c) % mod;
}
void fun() {
long long int n;
cin >> n;
long long int preP = INT_MAX, preC = INT_MAX;
long long int cP, cC, flag = 0;
for (long long int i = 1; i <= n; i++) {
cin >> cP >> cC;
if (i != 1) {
if (cP == preP && cC > preC) {
flag = 1;
}
if (cP >= preP && cC >= preC && cC <= cP) {
} else {
flag = 1;
}
long long int dC = cC - preC;
long long int dP = cP - preP;
if (dC > dP) flag = 1;
}
if (i == 1) {
if (cC <= cP) {
} else {
flag = 1;
}
}
preP = cP, preC = cC;
}
if (flag == 1) {
cout << "NO" << '\n';
return;
}
cout << "YES" << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
unsigned long long int t;
cin >> t;
while (t--) {
cout << fixed;
cout << setprecision(10);
fun();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int par[200010][18];
int dep[200010];
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 18 - 1; i >= 0; i--)
if (dep[par[u][i]] >= dep[v]) u = par[u][i];
if (u == v) return u;
for (int i = 18 - 1; i >= 0; i--)
if (par[u][i] != par[v][i]) u = par[u][i], v = par[v][i];
return par[u][0];
}
int dist(int u, int v) {
int a = lca(u, v);
return dep[u] + dep[v] - 2 * dep[a];
}
int main() {
cin >> n;
dep[1] = 1;
for (int i = 2; i <= n; i++) {
cin >> par[i][0];
dep[i] = dep[par[i][0]] + 1;
}
for (int j = 1; j < 18; j++)
for (int i = 1; i <= n; i++) par[i][j] = par[par[i][j - 1]][j - 1];
int u = 1, v = 1;
for (int i = 2; i <= n; i++) {
if (dist(u, i) > dist(u, v))
v = i;
else if (dist(v, i) > dist(u, v))
u = i;
cout << dist(u, v) << ' ';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int c = 0;
for (int i = 0; i < n; i++) {
if (a[i] <= k) c++;
if (a[i] > k) break;
}
if (c != n) {
for (int i = n - 1; i >= 0; i--) {
if (a[i] <= k)
c++;
else
break;
}
}
cout << c << endl;
}
| 1 |
#include<iostream>
#include<queue>
using namespace std;
int main(){
int n,k,m,c;
queue<int> stone;
while(cin >>n>>k>>m,n||k||m){
for(int i=0; i<n; i++){stone.push(i+1);}
for(int i=0; i<m-1; i++){
c = stone.front();
stone.pop();
stone.push(c);
}
stone.pop();
for(int i=1; i<n; i++){
for(int i=0; i<(k-1)%stone.size(); i++){
c = stone.front();
stone.pop();
stone.push(c);
}
c = stone.front();
stone.pop();
}
cout <<c<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
int main() {
int A, B, C, D;
scanf("%d %d %d %d", &A, &B, &C, &D);
printf("%d", std::max(A * B, C * D));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int a[25], b[25], dp[50][50];
vector<vector<long long> > c(const vector<vector<long long> > &a,
const vector<vector<long long> > &b) {
long long int size = a.size();
vector<vector<long long> > MP(size,
vector<long long>(size, 1000000000000000000));
for (int k = 0; k < size; k++)
for (int i = 0; i < size; i++)
for (int j = 0; j < size; j++)
MP[i][j] = min(MP[i][j], a[i][k] + b[k][j]);
return MP;
}
vector<vector<long long> > f(vector<vector<long long> > a, int p) {
long long int size = a.size();
vector<vector<long long> > MP(size,
vector<long long>(size, 1000000000000000000));
for (int i = 0; i < size; i++) MP[i][i] = 0;
while (p > 0) {
if (p & 1) MP = c(MP, a);
a = c(a, a);
p /= 2;
}
return MP;
}
int main() {
long long int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i - 1];
for (int i = 1; i <= n; i++) cin >> b[i - 1];
vector<vector<long long> > x(n + 1,
vector<long long>(n + 1, 1000000000000000000));
for (int k = 0; k < n + 1; k++) {
for (int i = 0; i < 32; i++)
for (int j = 0; j < 32; j++) dp[i][j] = 1000000000000000000;
dp[0][k] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n + 1; j++) {
if (j > 0) dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - 1] + a[i]);
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j + 1] + b[i]);
}
}
for (int i = 0; i < n + 1; i++) x[k][i] = dp[n][i];
}
cout << f(x, m)[0][0] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main(){
int N, K;
cin >> N >> K;
int x[N];
for(int i = 0; i < N; i++){
cin >> x[i];
}
int ans = INF;
for(int i = 0; i <= N - K; i++){
ans = min(ans, min(abs(x[i])+ abs(x[i+K-1]-x[i]), abs(x[i+K-1])+abs(x[i+K-1]-x[i])));
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, mx, bas = 1, h[50];
char a[1000005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (a[i] <= 'z' and a[i] >= 'a') {
h[a[i] - 'a']++;
continue;
}
if (a[i] >= 'A' and a[i] <= 'Z') {
int ans = 0;
for (int i = 0; i <= 50; i++)
if (h[i]) ans++;
mx = max(mx, ans);
memset(h, 0, sizeof(h));
}
}
int ans = 0;
for (int i = 0; i <= 50; i++)
if (h[i]) ans++;
mx = max(mx, ans);
memset(h, 0, sizeof(h));
cout << mx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int r, c, n, k, x, y, ans;
int a[20][20];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> r >> c;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x >> y;
a[x][y] = 1;
}
for (int i = 1; i <= r; i++)
for (int j = 1; j <= c; j++)
for (int x = i; x <= r; x++)
for (int y = j; y <= c; y++) {
int cnt = 0;
for (int I = i; I <= x; I++)
for (int J = j; J <= y; J++) cnt += a[I][J];
if (cnt >= k) ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int m,n,q,A[20];
int ans(int x,int y){
if(x==0)return 0;
if(y>=n)return 1;
if(ans(x,y+1)==0 || ans(x-A[y],y+1)==0)return 0;
else return 1;
}
int main(){
cin>>n;
for(int i=0;i<n;i++)cin>>A[i];
cin>>q;
for(int i=0;i<q;i++){
cin>>m;
if(ans(m,0)==0)cout<<"yes"<<endl;
else cout<<"no"<<endl;
}
} | 0 |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
struct st {
int t, s, d;
};
bool b[20000];
st p[20000];
int main() {
int n, m;
while (scanf("%d%d", &n, &m), n) {
rep(i, m) {
int t, s, d; scanf("%d%d%d", &t, &s, &d);
p[i] = { t,s - 1,d - 1 };
}
sort(p, p + m, [](st a, st b) {return a.t < b.t; });
memset(b, 0, sizeof(b));
b[0] = 1;
rep(i, m)b[p[i].d] |= b[p[i].s];
printf("%d\n", count(b, b + n, 1));
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, s, k;
int r[51];
int color[51];
vector<int> v[51];
int pd[2001][51];
int func(int c, int idx) {
if (c <= 0) return 0;
if (pd[c][idx] != -1) return pd[c][idx];
int ans = 1000000;
for (int i = 0; i < v[idx].size(); i++) {
int t = v[idx][i];
int cost = abs(idx - t);
ans = min(ans, func(c - r[t], t) + cost);
}
return pd[c][idx] = ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> s >> k;
s--;
memset(pd, -1, sizeof pd);
for (int i = 0; i < n; i++) cin >> r[i];
string sColors;
cin >> sColors;
for (int i = 0; i < n; i++) {
color[i] = ((sColors[i] == 'R') ? 0 : ((sColors[i] == 'G') ? 1 : 2));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (r[j] > r[i] && color[i] != color[j]) {
v[i].push_back(j);
}
}
}
int best = 1000000;
for (int i = 0; i < n; i++) {
best = min(best, func(k - r[i], i) + abs(s - i));
}
if (best > 51 * 51) best = -1;
cout << best << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
void read(vector<long long> &v) {
for (int i = 0; i < v.size(); i++) cin >> v[i];
}
long long n, m, a, b, c, k, temp, x, y;
void solveforthiscase(const int &test) {
long double f1, f2;
cin >> x >> y;
f1 = log(x);
f2 = log(y);
f1 *= y;
f2 *= x;
if (f1 > f2) {
cout << '>';
} else if (f1 == f2) {
cout << "=";
} else
cout << "<";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
for (int i = 1; i <= test; i++) {
solveforthiscase(i);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[21], b[21];
scanf("%s%s", a, b);
int cnt1 = 0, cnt2 = 0;
int len = strlen(a);
for (int i = 0; i < len; i += 2) {
if (a[i] == '8') {
if (b[i] == '[') {
cnt1++;
} else if (b[i] == '(') {
cnt2++;
}
} else if (a[i] == '[') {
if (b[i] == '(') {
cnt1++;
} else if (b[i] == '8') {
cnt2++;
}
} else if (a[i] == '(') {
if (b[i] == '8') {
cnt1++;
} else if (b[i] == '[') {
cnt2++;
}
}
}
if (cnt1 > cnt2) {
printf("TEAM 1 WINS\n");
} else if (cnt1 < cnt2) {
printf("TEAM 2 WINS\n");
} else {
printf("TIE\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long p10[10] = {};
p10[0] = 1;
for (int i = 1; i <= 9; ++i) p10[i] = p10[i - 1] * 10;
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
k++;
long long a[n], ans = 0;
for (int i = 0; i <= n - 1; ++i) cin >> a[i];
for (int i = 1; i <= n - 1; ++i) {
long long take = min(k, p10[a[i] - a[i - 1]] - 1);
ans += p10[a[i - 1]] * take;
k -= take;
}
ans += p10[a[n - 1]] * k;
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, v;
} b[200005];
bool operator<(node p, node q) {
if (p.x == q.x) {
if (p.y == q.y) {
return p.v < q.v;
}
return p.y < q.y;
}
return p.x < q.x;
}
int main() {
int t, n, x, y, ans, l, r;
cin >> t;
string s;
while (t--) {
cin >> n >> s;
x = y = 200000;
ans = 99999999;
for (int i = 0; i < n; i++) {
if (s[i] == 'U') {
y--;
}
if (s[i] == 'D') {
y++;
}
if (s[i] == 'L') {
x--;
}
if (s[i] == 'R') {
x++;
}
b[i].x = x;
b[i].y = y;
b[i].v = i;
}
b[n].x = 200000;
b[n].y = 200000;
b[n].v = -1;
sort(b, b + n + 1);
for (int i = 1; i <= n; i++) {
if (b[i].x == b[i - 1].x && b[i].y == b[i - 1].y) {
if (ans > b[i].v - b[i - 1].v) {
ans = b[i].v - b[i - 1].v;
l = b[i - 1].v;
r = b[i].v;
}
}
}
if (ans == 99999999)
cout << -1 << endl;
else
cout << l + 2 << ' ' << r + 1 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int DIM = 100005;
deque<int> que;
vector<int> lst, edg[DIM];
bool oki[DIM];
int val[DIM];
int main(void) {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
edg[x].push_back(y);
edg[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
cin >> val[i];
if (!val[i]) {
que.push_back(i);
oki[i] = true;
}
}
for (; que.size(); que.pop_front()) {
int x = que.front();
lst.push_back(x);
for (int y : edg[x]) {
if (oki[y]) continue;
if (--val[y] == 0) {
oki[y] = true;
que.push_back(y);
}
}
}
cout << lst.size() << "\n";
for (int x : lst) cout << x << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<long long, long long>;
const long long INF = 2e18;
template <class A, class B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class A>
ostream &operator<<(ostream &os, const vector<A> &v) {
os << "{";
for (long long i = 0; i < (long long)v.size(); i++)
if (i == 0)
os << v[i];
else
os << ", " << v[i];
os << "}";
return os;
}
void dprint(string s) { cout << "\n"; }
template <class T, class... U>
void dprint(string s, T t, U... u) {
long long w = s.find(',');
cout << "[" << s.substr(0, w) << ": " << t << "] ";
dprint(s.substr(w + 2, (long long)s.size() - w - 1), u...);
}
const long long N = 1e6 + 5;
void solve() {
long long n;
cin >> n;
long long arr[n];
for (long long &x : arr) cin >> x;
sort(arr, arr + n);
long long sum = 0;
for (long long i = 0; i < n - 1; i++) {
sum += arr[i];
}
if (arr[n - 1] > sum or n == 1) {
cout << "T\n";
return;
}
sum += arr[n - 1];
if (sum % 2 == 0)
cout << "HL";
else
cout << "T";
cout << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T;
cin >> T;
for (long long tc = 1; tc <= T; tc++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int orderm[21];
int table[21][21];
bool checkvalid();
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> table[i][j];
for (int i = 1; i <= m; i++) orderm[i] = i;
bool valid = checkvalid();
if (!valid) {
for (int i = 1; i <= m; i++) {
for (int j = i + 1; j <= m; j++) {
swap(orderm[i], orderm[j]);
valid = checkvalid();
if (valid) break;
swap(orderm[i], orderm[j]);
}
if (valid) break;
}
}
if (valid)
cout << "YES";
else
cout << "NO";
return 0;
}
bool checkvalid() {
for (int i = 1; i <= n; i++) {
int misplaced = 0;
for (int j = 1; j <= m; j++) {
if (table[i][orderm[j]] != j) misplaced++;
}
if (misplaced > 2) return false;
}
return true;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
long long size(const T &x) {
return x.size();
}
const long long INF = ~(1 << 31);
const double pi = acos(-1);
const double EPS = 1e-9;
int main() {
cin.sync_with_stdio(false);
long long n;
long long cnt = 0;
long long num = 0;
cin >> n;
vector<long long> arr(n);
for (long long i = (0); i < (n); i++) cin >> arr[i];
for (long long i = (0); i < (n); i++) {
cnt += abs(num - arr[i]);
num = arr[i];
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <string>
#include <map>
#include <vector>
using namespace std;
int list[10000][6];
int ko[10000][4];
bool check(int a,int b,int c,int d){
int e[10]={0};
e[a]++;e[b]++;e[c]++;e[d]++;
for(int i=0;i<10;i++)if(e[i]>1)return 0;
return 1;
}
int main(){
int N;
while(cin>>N,N){
int C,H,B;
int cnt=0;
for(int i=0;i<N;i++){
for(int j=3;j<6;j++)cin>>list[i][j];
for(int j=3;j>0;j--){
list[i][j-1]=list[i][j]/10;
list[i][j]%=10;
}
}
for(int i=0;i<=9;i++){
for(int j=0;j<=9;j++){
for(int k=0;k<=9;k++){
for(int l=0;l<=9;l++){
if(check(i,j,k,l)){
int flag=1;
for(int m=0,h,b;m<N;m++){
h=0;
b=0;
if(list[m][0]==i)h++;
if(list[m][1]==j)h++;
if(list[m][2]==k)h++;
if(list[m][3]==l)h++;
if(list[m][0]==j || list[m][0]==k || list[m][0]==l )b++;
if(list[m][1]==i || list[m][1]==k || list[m][1]==l )b++;
if(list[m][2]==i || list[m][2]==j || list[m][2]==l )b++;
if(list[m][3]==i || list[m][3]==j || list[m][3]==k )b++;
if(!(list[m][4]==h&&list[m][5]==b))flag=0;
}
if(flag){
ko[cnt][0]=i;
ko[cnt][1]=j;
ko[cnt][2]=k;
ko[cnt][3]=l;
cnt++;
}
}
}
}
}
}
if(cnt==1){
for(int i=0;i<4;i++)cout<<ko[0][i];
cout<<endl;
}
else{
int que=-1;
int d[6];
for(d[4]=0123;d[4]<=9876&&que<0;d[4]++){
d[3]=d[4];
for(d[6]=3;d[6]>0;d[6]--){
d[d[6]-1]=d[d[6]]/10;
d[d[6]]%=10;
}
if(check(d[0],d[1],d[2],d[3])){
int hb[5][5]={0};
for(int i=0;i<cnt;i++){
int h=0,b=0;
for(int j=0;j<4;j++)if(ko[i][j]==d[j])h++;
for(int j=0;j<4;j++)for(int k=0;k<4;k++)if(ko[i][j]==d[k])b++;
b-=h;
hb[h][b]++;
}
int flag=1;
for(int i=0;i<5;i++)for(int j=0;j<5;j++)if(hb[i][j]>1)flag=0;
if(flag){
que=d[0]*1000+d[1]*100+d[2]*10+d[3];
for(int i=0;i<4;i++)cout<<d[i];
cout<<endl;
}
}
}
if(que<0)cout<<"????"<<endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long inf = 2e9;
long long w, m;
void solve(long long x, long long y) {
if (x == m) {
cout << "YES\n";
exit(0);
}
if (y > inf) return;
solve(x + y, y * w);
solve(x - y, y * w);
solve(x, y * w);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> w >> m;
if (w <= 3) return cout << "YES", 0;
solve(0, 1);
cout << "NO";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class FenwickTree {
private:
vector<int> ft;
public:
FenwickTree(int n) { ft.assign(n + 1, 0); }
int rsq(int b) {
int sum = 0;
for (; b; b -= (b & (-b))) {
sum += ft[b];
}
return sum;
}
int rsq(int a, int b) {
if (a > b) return 0;
return rsq(b) - rsq(a - 1);
}
void update(int a, int v) {
for (; a < (int)ft.size(); a += (a & (-a))) {
ft[a] += v;
}
}
void update(int a, int b, int v) {
update(a, v);
update(b + 1, -v);
}
};
class TaskB {
public:
void solve(istream& in, ostream& out) {
int n;
in >> n;
vector<int> p(n);
for (int i = 0; i < n; ++i) {
in >> p[i];
}
out << 1;
FenwickTree ft(n);
vector<int> arr(n + 1, 0);
for (int i = 0, zero = n; i < n - 1; ++i) {
arr[p[i]] = 1;
ft.update(p[i], 1);
while (arr[zero]) --zero;
assert(zero >= 1);
out << " " << ft.rsq(1, zero) + 1;
}
out << " " << 1 << "\n";
}
};
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
TaskB solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
scanf("%d%d", &x, &y);
if (y == 0 && (x == 0 || x == 1)) {
printf("0\n");
return 0;
}
if (y >= x && y < -x) printf("%d\n", (abs(x) - 1) * 4 + 3);
if (y <= -x + 1 && y < x) printf("%d\n", (-y - 1) * 4 + 4);
if (y <= x && y > -x + 1) printf("%d\n", (x - 1) * 4 + 1);
if (y > x && y >= -x) printf("%d\n", (y - 1) * 4 + 2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> primesUntil(int n) {
vector<int> p;
p.push_back(2);
for (int i = 3; i <= n; ++i) {
for (int j = 0; j < p.size(); ++j) {
if (i % p[j] == 0) break;
if (p[j] * p[j] > i) {
p.push_back(i);
break;
}
}
}
return p;
}
vector<pair<int, int>> defactor(int v, const vector<int>& p) {
vector<pair<int, int>> ans;
int pid = 0;
while (v > 1) {
int cnt = 0;
while (v % p[pid] == 0) {
cnt++;
v = v / p[pid];
}
if (cnt) ans.push_back({p[pid], cnt});
pid++;
if (v > 1 && p[pid] * p[pid] > v) {
ans.push_back({v, 1});
break;
}
}
return ans;
}
void main_test() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> a(n);
for (int& v : a) cin >> v;
vector<int> p = primesUntil(2e5);
map<int, int> revp;
for (int i = 0; i < p.size(); ++i) {
revp[p[i]] = i;
}
vector<multiset<int>> scnt(p.size());
vector<int> tcnt(p.size(), 0);
auto add = [&](int pid, int cnt) {
tcnt[pid]++;
scnt[pid].insert(cnt);
if (scnt[pid].size() > 2) {
scnt[pid].erase(prev(scnt[pid].end()));
}
};
for (int i = 0; i < a.size(); ++i) {
int v = a[i];
vector<pair<int, int>> fact = defactor(v, p);
for (pair<int, int> pp : fact) {
add(revp[pp.first], pp.second);
}
}
long long res = 1;
for (int pid = 0; pid < p.size(); ++pid) {
if (tcnt[pid] <= n - 2) continue;
if (tcnt[pid] == n - 1)
for (int i = 0; i < *scnt[pid].begin(); ++i) {
res *= p[pid];
}
else
for (int i = 0; i < *next(scnt[pid].begin()); ++i) {
res *= p[pid];
}
}
cout << res;
}
using namespace std;
int main() {
main_test();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define N 5010
#define mod 998244353
int c[N][N];
inline int read() {
int x=0;
char ch=getchar();
while (!isdigit(ch)) ch=getchar();
while (isdigit(ch)) x=x*10+ch-'0',ch=getchar();
return x;
}
int Ans[N];
int main() {
int k=read(),n=read();
c[0][0]=1;
for (int i=1;i<N;i++) {
c[i][0]=1;
for (int j=1;j<=i;j++) {
c[i][j]=(c[i-1][j-1]+c[i-1][j])%mod;
}
}
// cout<<c[5][2]<<endl;
for (int i=2;i<=k+1;i++) {
int t=i/2,w=1,ans=0;
for (int j=0;j<=t && (j<<1)<=n;j++) {
(ans+=1LL*c[t][j]*c[n-2*j+k-1][k-1]*w%mod)%=mod,w*=-1;
}
printf("%d\n",Ans[i]=(ans+mod)%mod);
}
for (int i=k;i>=2;i--) printf("%d\n",Ans[i]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[504][504];
int v[1000005][3], nv;
void go(int step, int x, int y) {
if (x != -1 and y != -1 and s[x][y] == '.') {
s[x][y] = 'B';
v[nv][0] = 'B';
v[nv][1] = x;
v[nv][2] = y;
nv++;
go(step + 1, x + 1, y);
go(step + 1, x - 1, y);
go(step + 1, x, y + 1);
go(step + 1, x, y - 1);
if (step) {
v[nv][0] = 'D';
v[nv][1] = x;
v[nv][2] = y;
nv++;
v[nv][0] = 'R';
v[nv][1] = x;
v[nv][2] = y;
nv++;
s[x][y] = 'R';
}
}
}
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++)
if (s[i][j] == '.') go(0, i, j);
printf("%d\n", nv);
for (int i = 0; i < nv; i++)
printf("%c %d %d\n", v[i][0], v[i][1] + 1, v[i][2] + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string S;
cin >> S;
cout << S.at(0) << S.at(1) << S.at(2);
}
| 0 |
// Rakib (CSE'19)
#include<bits/stdc++.h>
#define boost_ ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define pb push_back
#define read(i,n,a) for(ll i=0;i<n;++i) cin>>a[i]
#define print(i,a) for(auto i:a) cout<<i<< " " ; cout<<endl ;
#define dpoint(n) cout<<showpoint<<fixed<<setprecision(n)
#define all(a) a.begin(),a.end()
#define MOD 1000000007
#define vl vector<ll>
#define MP make_pair
#define MAX 100000
#define dbug(x) cout << #x << " is " << x << "\n";
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
int gcd(int x,int y){
if(!y) return x;
return gcd(y,x%y);
}
bool cmp(const vector<ll>&a ,const vector<ll>&b){
return (a.size() > b.size());
}
void task(ll case_no){
ll n;
cin >> n;
vl u(n),s(n);
read(i,n,u);
read(i,n,s);
vector<vector<ll>>v(n+1);
for(ll i=0;i<n;++i){
v[u[i]].pb(s[i]);
}
sort(all(v),cmp);
for(ll i=0;i<=n && v[i].size();++i){
sort(all(v[i]));
for(ll j=1;j<v[i].size();++j) v[i][j]+=v[i][j-1];
}
vl ans;
for(ll i=0;i<n;++i){
ll sum=0;
for(ll j=0;j<=n && v[j].size() && v[j].size()>=i+1;++j){
ll s=(v[j].size()/(i+1))*(i+1);
if(v[j].size()-s>0) sum+=v[j].back()-v[j][v[j].size()-1-s];
else sum+=v[j].back();
}
ans.pb(sum);
}
print(i,ans);
return;
}
int main(){
boost_;
ll t=1,i=0;
cin >> t;
while(t--){
task(++i);
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
const int N = 1e5 + 5;
int n, w, a[N], s = 0, p = 1e9;
vector<int> ret;
void print() {
for (auto x : ret) printf("%d ", x);
printf("\n");
}
int main() {
scanf("%d%d", &n, &w);
for (int i = (1); i < (n + 1); i++)
scanf("%d", &a[i]), s += a[i], p = min(p, a[i]);
if (w < 1 || w > s) return 0 * printf("No\n");
if (w == 1) {
if (p == 1) {
bool ok = 0;
int k;
for (int i = (1); i < (n + 1); i++)
if (!ok && a[i] == 1)
ok = 1, k = i;
else
for (int kk = (0); kk < (a[i]); kk++)
ret.push_back(i), ret.push_back(i);
ret.push_back(k), ret.insert(ret.begin(), k);
printf("Yes\n");
print();
return 0;
} else
return 0 * printf("No\n");
}
if (n == 1) {
if (w == a[1]) {
for (int i = (1); i < (2 * a[1] + 1); i++) ret.push_back(1);
printf("Yes\n");
print();
return 0;
} else
return 0 * printf("No\n");
}
a[1]--, a[2]--, w -= 2;
for (int i = n; i && w; i--) {
int k = min(w, a[i]);
a[i] -= k, w -= k;
for (int j = (0); j < (k); j++)
for (int op = (0); op < (2); op++) ret.push_back(i);
}
printf("Yes\n");
printf("1 ");
for (int i = (0); i < (a[2]); i++) printf("2 2 ");
for (int i = (3); i < (n + 1); i++)
for (int j = (0); j < (a[i]); j++)
for (int k = (0); k < (2); k++) printf("%d ", i);
printf("1 2 ");
for (int i = (0); i < (a[1]); i++) printf("1 1 ");
printf("2 ");
print();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 1000 * 1007;
const int INF = 1e9;
long long int pow(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
vector<int> s;
int ans = v[0] ^ v[1];
for (int i = 0; i < n; i++) {
while (s.size() != 0 && s.back() < v[i]) s.pop_back();
s.push_back(v[i]);
if (s.size() >= 2) ans = max(ans, s[s.size() - 1] ^ s[s.size() - 2]);
}
s.clear();
reverse(v.begin(), v.end());
ans = max(ans, v[0] ^ v[1]);
for (int i = 0; i < n; i++) {
while (s.size() != 0 && s.back() < v[i]) s.pop_back();
s.push_back(v[i]);
if (s.size() >= 2) ans = max(ans, s[s.size() - 1] ^ s[s.size() - 2]);
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x; i <= y; i++)
using namespace std;
const int N = 1e6 + 10;
int pre[N], n, sub[N];
char s[N], t[N];
bool chkpre(int x) {
return x % (x - pre[x]) > 0 || !pre[x];
}
bool chksub(int x) {
return x % (x - sub[x]) > 0 || !sub[x];
}
void getfail(char *s, int *nxt) {
nxt[0] = nxt[1] = 0;
int j = 0;
rep(i, 1, n - 1) {
while(j && s[i] != s[j]) j = nxt[j];
nxt[i + 1] = (s[i] == s[j] ? ++j : 0);
}
}
int main() {
scanf("%s", s);
n = strlen(s);
rep(i, 0, n - 1) t[i] = s[n - i - 1];
t[n] = '\0';
getfail(s, pre), getfail(t, sub);
int flag = chkpre(n) ? 1 : 2;
if (n - pre[n] == 1) flag = n;
printf("%d\n", flag);
if (flag != 2) { puts("1"); return 0; }
int ans = 0;
rep(i, 1, n) {
int x = n - i;
if (chkpre(i) && chksub(x)) ans++;
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m = 0;
int n = 0;
cin >> m;
cin >> n;
vector<vector<char> > vec(m, vector<char>(n, 0));
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> vec[i][j];
}
}
int count_s = 0;
for (int i = 0; i < m; i++) {
count_s = 0;
for (int j = 0; j < n; j++) {
if (vec[i][j] == 'S') {
count_s++;
}
}
for (int j = 0; j < n; j++) {
if (count_s == 0) {
vec[i][j] = 'e';
}
}
}
for (int i = 0; i < n; i++) {
count_s = 0;
for (int j = 0; j < m; j++) {
if (vec[j][i] == 'S') {
count_s++;
}
}
for (int j = 0; j < m; j++) {
if (count_s == 0) {
vec[j][i] = 'e';
}
}
}
int num_eaten = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (vec[i][j] == 'e') {
num_eaten++;
}
}
}
cout << num_eaten;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
string s;
int len, match[1005];
long long dp[1000][1000][3][3];
void get_match() {
stack<int> sta;
for (int i = 0; i < len; i++) {
if (s[i] == '(')
sta.push(i);
else {
int t = sta.top();
sta.pop();
match[i] = t;
match[t] = i;
}
}
}
void dfs(int l, int r) {
if (l + 1 == r) {
dp[l][r][0][1] = 1;
dp[l][r][1][0] = 1;
dp[l][r][0][2] = 1;
dp[l][r][2][0] = 1;
return;
}
if (match[l] == r) {
dfs(l + 1, r - 1);
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
if (j != 1)
dp[l][r][0][1] = (dp[l][r][0][1] + dp[l + 1][r - 1][i][j]) % mod;
if (i != 1)
dp[l][r][1][0] = (dp[l][r][1][0] + dp[l + 1][r - 1][i][j]) % mod;
if (j != 2)
dp[l][r][0][2] = (dp[l][r][0][2] + dp[l + 1][r - 1][i][j]) % mod;
if (i != 2)
dp[l][r][2][0] = (dp[l][r][2][0] + dp[l + 1][r - 1][i][j]) % mod;
}
return;
} else {
int k = match[l];
dfs(l, k);
dfs(k + 1, r);
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
for (int x = 0; x < 3; x++)
for (int y = 0; y < 3; y++) {
if ((x == 1 && y == 1) || (x == 2 && y == 2)) continue;
dp[l][r][i][j] =
(dp[l][r][i][j] + dp[l][k][i][x] * dp[k + 1][r][y][j]) % mod;
}
return;
}
}
int main() {
memset(dp, 0, sizeof(dp));
cin >> s;
len = s.size();
get_match();
dfs(0, len - 1);
long long ans = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) ans = (ans + dp[0][len - 1][i][j]) % mod;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MX = 1e9 + 7;
vector<pair<int, int> > v[5000050];
void print(vector<long long> const &input) {
for (int i = 0; i < input.size(); i++) {
cout << input.at(i) << ' ';
}
cout << "\n";
}
void solve(int m) {}
int main() {
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
string s;
long long sum = 0;
cin >> s;
long long cnt1 = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1')
cnt1++;
else {
long long place = min(cnt1, b);
b -= place;
s[i] = '1';
s[i - place] = '0';
}
}
cout << s << "\n";
}
}
| 4 |
#include <cstdio>
int n, x, d;
int main() {
scanf("%d%d", &n, &x);
if(x==1 || x==2*n-1) return puts("No"), 0;
puts("Yes");
d = n-x; n += n-1;
for(int i=0; i<n; i++) printf("%d\n", (i-d+n)%n+1);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int sum[200010], n, dp[200010][2];
int mxv, mnv;
int main() {
scanf("%d", &n);
dp[n][0] = dp[n][1] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &sum[i]);
sum[i] += sum[i - 1];
}
mxv = sum[n];
mnv = -sum[n];
for (int i = n - 1; i >= 1; i--) {
dp[i][1] = mnv;
dp[i][0] = mxv;
mxv = max(mxv, dp[i][1] + sum[i]);
mnv = min(mnv, dp[i][0] - sum[i]);
}
printf("%d\n", dp[1][0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210;
struct node {
int v, next, use;
} edge[MAXN << 2];
bool bridge[MAXN];
int low[MAXN], dfn[MAXN], vis[MAXN];
int head[MAXN], pre[MAXN], ip, sol, Count, u[MAXN], v[MAXN], n, m, p[MAXN], i,
viss[MAXN], s, ans = -1, j, t[MAXN];
void init(void) {
memset(head, -1, sizeof(head));
memset(vis, false, sizeof(vis));
memset(bridge, false, sizeof(bridge));
Count = sol = ip = 0;
}
void addedge(int u, int v) {
edge[ip].v = v;
edge[ip].use = 0;
edge[ip].next = head[u];
head[u] = ip++;
}
bool flag;
void tarjan(int u) {
vis[u] = 1;
dfn[u] = low[u] = Count++;
for (int i = head[u]; i != -1; i = edge[i].next) {
if (!edge[i].use) {
edge[i].use = edge[i ^ 1].use = 1;
int v = edge[i].v;
if (!vis[v]) {
pre[v] = u;
tarjan(v);
low[u] = min(low[u], low[v]);
if (dfn[u] < low[v]) {
sol++;
flag = 0;
}
} else if (vis[v] == 1) {
low[u] = min(low[u], dfn[v]);
}
}
}
vis[u] = 2;
}
int main(void) {
scanf("%d %d", &n, &m);
for (i = 1; i <= m; i++) scanf("%d %d", &u[i], &v[i]);
for (i = 1; i <= m; i++) p[i] = i;
for (int jo = 1; jo <= 2000; jo++) {
for (i = 1; i <= 100; i++) {
int x = rand() % m + 1, y = rand() % m + 1;
swap(p[x], p[y]);
}
memset(viss, 0, sizeof(viss));
for (i = 1; i <= m; i++) {
init();
viss[i] = 1;
for (j = 1; j <= m; j++)
if (viss[j] == 0) {
addedge(u[p[j]], v[p[j]]);
addedge(v[p[j]], u[p[j]]);
}
flag = 1;
tarjan(1);
for (j = 1; j <= n; j++)
if (vis[j] == 0) flag = 0;
if (!flag) viss[i] = 0;
}
s = 0;
for (i = 1; i <= m; i++)
if (viss[i] == 1) s++;
if (ans < s) {
ans = s;
int y = 0;
for (i = 1; i <= m; i++)
if (viss[i] == 0) t[++y] = p[i];
}
}
cout << m - ans << endl;
for (i = 1; i <= m - ans; i++) printf("%d %d\n", u[t[i]], v[t[i]]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int c[110], g[110][110], n, m, sum = 0, min = 10000000;
cin >> n >> m;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) g[i][j] = 0;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a][b] = 1;
g[b][a] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if ((i != j) && (g[i][j]))
for (int k = 1; k <= n; k++)
if ((k != i) && (k != j) && (g[k][i]) && (g[k][j])) {
sum = c[i] + c[j] + c[k];
if (sum < min) min = sum;
}
if (min == 10000000)
cout << -1;
else
cout << min;
}
| 1 |
#include<cstdio>
#include<algorithm>
using namespace std;
#define LL long long
const int maxn = 5e3 + 5;
const LL mod = 1e9 + 7;
LL x[maxn], cnt[maxn];
LL dp[maxn][maxn];
int main()
{
// freopen("in.txt","r",stdin);
int n, k, q;scanf("%d %d %d",&n,&k,&q);
for(int i = 1;i <= n;i++)scanf("%lld",&x[i]),dp[i][0] = 1;
for(int i = 1;i <= k;i++)
for(int j = 1;j <= n;j++)
{
dp[j][i] = (dp[j - 1][i - 1] + dp[j + 1][i - 1]) % mod;
}
for(int i = 0;i <= k;i++)
for(int j = 1;j <= n;j++)
{
cnt[j] = (cnt[j] + dp[j][i] * dp[j][k - i] % mod) % mod;
}
LL ans = 0;
for(int i = 1;i <= n;i++)ans = (ans + cnt[i] * x[i] % mod) % mod;
while(q--)
{
int index;LL val;
scanf("%d %lld",&index,&val);
ans = (ans + mod - cnt[index] * x[index] % mod) % mod;
ans = (ans + cnt[index] * val % mod) % mod;
x[index] = val;
printf("%lld\n",ans);
}
return 0;
} | 4 |
#include <bits/stdc++.h>
const int N = 2e5 + 5;
const int INF = 0x3f3f3f3f;
using namespace std;
int T, n, f[N][2], a[N], sum[N];
template <typename T>
inline T read() {
T x = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * w;
}
int main() {
T = read<int>();
while (T--) {
n = read<int>();
for (int i = 1; i <= n; i++) a[i] = read<int>(), sum[i] = sum[i - 1] + a[i];
for (int i = 0; i <= n; i++) f[i][0] = f[i][1] = INF;
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
if (i >= 1)
f[i][0] = min(f[i][0], f[i - 1][1]),
f[i][1] = min(f[i][1], f[i - 1][0] + sum[i] - sum[i - 1]);
if (i >= 2)
f[i][0] = min(f[i][0], f[i - 2][1]),
f[i][1] = min(f[i][1], f[i - 2][0] + sum[i] - sum[i - 2]);
}
printf("%d\n", min(f[n][0], f[n][1]));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int down(int a, int b) {
if (a >= b) {
return a - b;
} else
return a + 1 + (n - 1) - b;
}
int up(int a, int b) {
if (a > b) {
return n - 1 - a + b + 1;
} else
return b - a;
}
int main() {
cin >> n;
int i;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
int flag = 1;
int ans;
ans = up(a[0], 0);
for (i = 1; i < n; i++) {
if (i % 2 != 0) {
if (down(a[i], i) != ans) {
flag = 0;
goto out;
}
} else {
if (up(a[i], i) != ans) {
flag = 0;
goto out;
}
}
}
out:
if (flag) {
cout << "Yes";
} else
cout << "No";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string k;
cin >> k;
set<char> s;
for (int i = 0; i < k.size(); i++) {
s.insert(k[i]);
}
if (s.size() % 2 == 0) {
cout << "CHAT WITH HER!\n";
} else if (s.size() % 2 != 0) {
cout << "IGNORE HIM!\n";
}
}
| 1 |
#include <iostream>
int main() {
int N;
std::cin >> N;
std::cout << (N-2) * 180 << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
long long power(long long x, long long y) {
long long res = 1;
x = x % MOD;
while (y > 0) {
if (y & 1) res = (res * x) % MOD;
y = y >> 1;
x = (x * x) % MOD;
}
return res;
}
long long modInverse(long long x) { return power(x, MOD - 2); }
long long modAdd(long long a, long long b) {
return (a % MOD + b % MOD + 2 * MOD) % MOD;
}
long long modMult(long long a, long long b) {
return (a % MOD * b % MOD) % MOD;
}
long long modDiv(long long a, long long b) {
return (a % MOD * modInverse(b)) % MOD;
}
void nikal_pehli_fursat_mai() {
long long n, k;
cin >> n >> k;
map<long long, long long> a, b;
a[-1] = -1;
a[n] = -1;
map<long long, long long> ind;
for (int i = 0; i < n; i++) {
cin >> a[i];
ind[a[i]] = i;
}
map<long long, long long> check;
check[-1] = k;
for (int i = 0; i < k; i++) {
cin >> b[i];
check[b[i]] = i + 1;
}
long long ans = 1;
for (int j = 0; j < k; j++) {
int i = ind[b[j]];
if (check[a[i]] > 0) {
if (check[a[i - 1]] > 0 and check[a[i + 1]] > 0) {
ans = 0;
break;
} else if (check[a[i - 1]] > 0 or check[a[i + 1]] > 0)
ans *= 1;
else if (check[a[i - 1]] == 0 and check[a[i + 1]] == 0)
ans *= 2;
}
ans %= MOD;
check[a[i]] = 0;
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tc = 1;
cin >> tc;
while (tc--) {
nikal_pehli_fursat_mai();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int p[1000000];
bool vis[100000 + 10];
int main() {
bool f = 0;
string s;
int ct = 0;
cin >> s;
char curp = '0';
for (int i = 0; i < s.size(); i++) {
if (s[i] == curp)
ct++;
else
ct = 1;
curp = s[i];
if (ct == 7) f = 1;
}
if (f) cout << "YES" << endl;
if (!f) cout << "NO" << endl;
return 0;
}
| 1 |
#include<stdio.h>
int main()
{
int e,y,z,m,ans=100000000;
while(1){
scanf("%d",&e);
ans=100000000;
if(e==0)
break;
else{
for(y=0; y<=1000; y++){
for(z=0; z<=100; z++){
m=e-y*y-z*z*z+y+z;
if(ans>m && e-y*y-z*z*z>=0)
ans=m;
}
}
printf("%d\n",ans);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 3001;
using namespace std;
vector<int> G[N], rG[N], q[N];
int d[N][N];
bool vis[N];
int c[N][3], rc[N][3];
void bfs(int k, vector<int> g[], bool f) {
int h = 0, t = 1, i, p;
memset(vis, false, sizeof(vis));
q[k].clear();
q[k].push_back(k);
if (f) d[k][k] = 0;
vis[k] = true;
h = 0;
t = 1;
while (h < t) {
p = q[k][h++];
for (i = 0; i < g[p].size(); i++)
if (!vis[g[p][i]]) {
if (f) d[k][g[p][i]] = d[k][p] + 1;
q[k].push_back(g[p][i]);
vis[g[p][i]] = true;
t++;
}
}
}
int main() {
int n, m;
int i, j, k, l, a, b;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
a--;
b--;
G[a].push_back(b);
rG[b].push_back(a);
}
memset(d, -1, sizeof(d));
for (i = 0; i < n; i++) bfs(i, G, true);
memset(c, -1, sizeof(c));
for (i = 0; i < n; i++) {
for (j = q[i].size() - 1; j >= (int)q[i].size() - 3 && j > 0; j--) {
c[i][q[i].size() - 1 - j] = q[i][j];
}
}
for (i = 0; i < n; i++) bfs(i, rG, false);
memset(rc, -1, sizeof(c));
for (i = 0; i < n; i++)
for (j = q[i].size() - 1; j >= (int)q[i].size() - 3 && j > 0; j--) {
rc[i][q[i].size() - 1 - j] = q[i][j];
}
int s = 0, v1 = -1, v2 = -1, v3 = -1, v4 = -1;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (d[i][j] != -1 && i != j) {
for (k = 0; k < 3 && rc[i][k] != -1; k++)
for (l = 0; l < 3 && c[j][l] != -1; l++) {
if (rc[i][k] != c[j][l] && rc[i][k] != j && c[j][l] != i) {
if (d[rc[i][k]][i] + d[i][j] + d[j][c[j][l]] > s) {
s = d[rc[i][k]][i] + d[i][j] + d[j][c[j][l]];
v1 = rc[i][k];
v2 = i;
v3 = j;
v4 = c[j][l];
}
}
}
}
printf("%d %d %d %d\n", v1 + 1, v2 + 1, v3 + 1, v4 + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int a, b, t, index;
};
struct Constraint {
int a, b, best0, best1;
vector<int> sol0, sol1;
int cons;
};
void nope() {
cout << "No\n";
exit(0);
}
void dfs(int node, vector<vector<edge>> &G, vector<int> &seen, int &end,
int par, vector<int> &best, vector<vector<int>> &e, int from = -1) {
seen[node] = 1;
end = node;
for (auto edge : G[node]) {
int to = edge.b;
if (to == node) to = edge.a;
if (edge.index == from) continue;
best[par] = max(best[par], edge.t);
e[par].push_back(edge.index);
if (seen[to]) continue;
dfs(to, G, seen, end, 1 - par, best, e, edge.index);
break;
}
}
bool match(int node, vector<vector<int>> &G, vector<int> &seen, vector<int> &L,
vector<int> &R) {
if (seen[node]) return false;
seen[node] = 1;
for (auto temp : G[node])
if (R[temp] == -1) {
L[node] = temp;
R[temp] = node;
return true;
}
for (auto temp : G[node])
if (match(R[temp], G, seen, L, R)) {
L[node] = temp;
R[temp] = node;
return true;
}
return false;
}
vector<int> getMatching(int n, int m, vector<vector<int>> &G) {
vector<int> L(n, -1), R(m, -1);
int ans = 0;
while (true) {
bool ok = false;
vector<int> seen(n, 0);
for (int i = 0; i < n; ++i)
if (L[i] == -1 && match(i, G, seen, L, R)) {
ok = true;
ans++;
}
if (!ok) break;
}
if (ans < m) return vector<int>();
return L;
}
int main() {
ios_base ::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<vector<edge>> G(n, vector<edge>());
vector<vector<edge>> C(m, vector<edge>());
unordered_map<int, int> norm;
vector<int> seen(n, 0);
vector<int> hasCycle(n, 0);
int cnt = 0;
for (int i = 0; i < m; ++i) {
int a, b, color, t;
cin >> a >> b >> color >> t;
a--, b--;
if (norm.count(color) == 0) norm[color] = cnt++;
C[norm[color]].push_back({a, b, t, i});
}
int cons = 0;
vector<Constraint> odd, even;
int ans = 0;
vector<int> sol;
for (int color = 0; color < cnt; ++color) {
unordered_set<int> nodes;
for (auto temp : C[color]) {
nodes.insert(temp.a);
nodes.insert(temp.b);
G[temp.a].push_back(temp);
G[temp.b].push_back(temp);
}
for (auto node : nodes) {
if (G[node].size() > 2) {
nope();
}
if (G[node].size() == 2 && hasCycle[node]) {
nope();
}
if (G[node].size() == 2) {
hasCycle[node] = 1;
}
}
for (auto node : nodes)
if (G[node].size() == 1 && !seen[node]) {
int start = node, end = -1;
vector<int> best(2, 0);
vector<vector<int>> e(2, vector<int>());
dfs(node, G, seen, end, 0, best, e);
int length = e[0].size() + e[1].size();
if (length == 1) continue;
if (length % 2 == 1) {
odd.push_back({start, end, best[0], best[1], e[0], e[1], 0});
continue;
}
even.push_back({start, end, best[0], best[1], e[0], e[1], cons++});
}
for (auto node : nodes) {
if (seen[node]) continue;
vector<vector<int>> e(2, vector<int>());
vector<int> best(2, 0);
int bla = 0;
if (G[node].size() == 2) dfs(node, G, seen, bla, 0, best, e, -1);
int length = e[0].size() + e[1].size();
if (length % 2 == 1) {
for (int i = 0; i < 2; ++i)
for (auto temp : e[i]) cerr << i << " " << temp << " ";
nope();
}
int x = 0;
if (best[0] > best[1]) x = 1;
for (auto temp : e[x]) sol.push_back(temp);
ans = max(ans, best[x]);
}
for (auto node : nodes) {
G[node].clear();
seen[node] = 0;
}
}
vector<int> aux = sol;
sol.clear();
int rAns = 0;
for (int lf = ans, rt = 1e9; lf <= rt;) {
int mid = (lf + rt) / 2;
bool can = true;
vector<int> tempSol = aux;
vector<int> dead = hasCycle;
vector<vector<int>> M(n, vector<int>());
for (auto temp : odd) {
if (temp.best0 > mid && temp.best1 > mid) can = false;
if (temp.best1 <= mid) {
for (auto edge : temp.sol1) tempSol.push_back(edge);
continue;
}
if (dead[temp.a] || dead[temp.b]) can = false;
dead[temp.a] = dead[temp.b] = 1;
for (auto edge : temp.sol0) tempSol.push_back(edge);
}
for (auto temp : even) {
if (!dead[temp.a] && temp.best0 <= mid) M[temp.a].push_back(temp.cons);
if (!dead[temp.b] && temp.best1 <= mid) M[temp.b].push_back(temp.cons);
}
vector<int> whoMatches = getMatching(n, cons, M);
if (whoMatches.empty())
can = false;
else {
for (int i = 0; i < n; ++i)
if (whoMatches[i] >= 0) {
int r = whoMatches[i];
if (even[r].a == i) {
for (auto temp : even[r].sol0) tempSol.push_back(temp);
} else {
for (auto temp : even[r].sol1) tempSol.push_back(temp);
}
}
}
if (can) {
rAns = mid;
rt = mid - 1;
sol = tempSol;
} else {
lf = mid + 1;
}
}
cout << "Yes\n";
cout << rAns << " " << sol.size() << "\n";
for (auto temp : sol) cout << temp + 1 << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int N;
cin >> N;
int arr[N];
for (int i = 0; i < N; i++) cin >> arr[i];
for (int i = 0; i < N; i++) {
int cnt = 1;
for (int j = 0; j < N; j++) {
if (arr[j] > arr[i]) {
cnt++;
}
}
cout << cnt << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool f[101][101], v[101];
int n, m, g[101][101], l[101][101], ans[101];
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
bool dfs(int x) {
v[x] = true;
for (int y = 1; y <= n; ++y) {
if (!f[x][y]) continue;
if ((ans[x] % g[x][y] != 0) || (l[x][y] % ans[x] != 0)) return false;
if (!v[y]) {
ans[y] = l[x][y] / ans[x] * g[x][y];
if ((gcd(ans[x], ans[y]) != g[x][y]) || (!dfs(y))) return false;
} else {
if ((gcd(ans[x], ans[y]) != g[x][y]) ||
(ans[y] != l[x][y] / ans[x] * g[x][y]))
return false;
}
}
return true;
}
int main(void) {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int j, k;
scanf("%d %d", &j, &k);
f[j][k] = true;
f[k][j] = true;
scanf("%d %d", &g[j][k], &l[j][k]);
if (l[j][k] % g[j][k] != 0) {
printf("NO\n");
return 0;
}
g[k][j] = g[j][k];
l[k][j] = l[j][k];
}
for (int i = 1; i <= n; ++i) {
if (ans[i] > 0) continue;
ans[i] = 1;
while (ans[i] <= 1000000) {
memset(v, 0, sizeof(v));
if (dfs(i)) break;
++ans[i];
}
if (ans[i] > 1000000) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
for (int i = 1; i < n; ++i) printf("%d ", ans[i]);
printf("%d\n", ans[n]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline char read() {
static const int IN_LEN = 1000000;
static char buf[IN_LEN], *s, *t;
return (s == t ? t = (s = buf) + fread(buf, 1, IN_LEN, stdin),
(s == t ? -1 : *s++) : *s++);
}
template <class T>
inline void read(T &x) {
static bool iosig;
static char c;
for (iosig = false, c = read(); !isdigit(c); c = read()) {
if (c == '-') iosig = true;
if (c == -1) return;
}
for (x = 0; isdigit(c); c = read()) x = ((x + (x << 2)) << 1) + (c ^ '0');
if (iosig) x = -x;
}
const int OUT_LEN = 10000000;
char obuf[OUT_LEN], *ooh = obuf;
inline void print(char c) {
if (ooh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), ooh = obuf;
*ooh++ = c;
}
template <class T>
inline void print(T x) {
static int buf[30], cnt;
if (x == 0)
print('0');
else {
if (x < 0) print('-'), x = -x;
for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
while (cnt) print((char)buf[cnt--]);
}
}
inline void flush() { fwrite(obuf, 1, ooh - obuf, stdout); }
long long n, H;
inline long long check(int x) {
if (x <= H) return (long long)x * (x + 1) / 2;
long long tmp = H + x >> 1;
if (tmp > 2e9) return 1e18 + 1;
return (H + tmp) * (tmp - H + 1) / 2 +
((H + x) & 1 ? tmp * (tmp + 1) / 2 : tmp * (tmp - 1) / 2);
}
int main() {
read(n), read(H);
int l = 1, r = 2e9 + 1, ans = 0;
while (l <= r) {
int mid = (long long)l + r >> 1;
if (check(mid) >= n)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
return printf("%d", ans), 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
using namespace std;
int n;
long long sum, ans, a[50005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]), sum += a[i];
long long k = sum / n;
for (int i = 1; i <= n; i++) {
if (a[i] != k) {
if (a[i] > k) {
long long d = a[i] - k;
a[i] -= d, a[i + 1] += d, ans += d;
} else if (a[i] < k) {
long long d = k - a[i];
a[i] += d, a[i + 1] -= d, ans += d;
}
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char field[2005][2005];
int cur = 0;
int sum(int x, int y) {
int c = 0;
if (x > 0)
if (field[x - 1][y] == '.') c++;
if (y > 0)
if (field[x][y - 1] == '.') c++;
if (field[x + 1][y] == '.') c++;
if (field[x][y + 1] == '.') c++;
return c;
}
bool paint(int &x, int &y) {
if (x > 0) {
if (field[x - 1][y] == '.') {
field[x][y] = 'v';
field[x - 1][y] = '^';
x--;
return true;
}
}
if (y > 0) {
if (field[x][y - 1] == '.') {
field[x][y] = '>';
field[x][y - 1] = '<';
y--;
return true;
}
}
if (field[x + 1][y] == '.') {
field[x][y] = '^';
field[x + 1][y] = 'v';
x++;
return true;
}
if (field[x][y + 1] == '.') {
field[x][y] = '<';
field[x][y + 1] = '>';
y++;
return true;
}
return false;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++) {
field[i][j] = s[j];
if (field[i][j] == '.') cur++;
}
}
queue<pair<int, int> > q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (field[i][j] == '.' && sum(i, j) == 1) {
q.push(make_pair(i, j));
}
}
}
while (!q.empty()) {
int x = q.front().first;
int y = q.front().second;
q.pop();
if (paint(x, y)) cur -= 2;
if (x > 0 && field[x - 1][y] == '.' && sum(x - 1, y) == 1) {
q.push(make_pair(x - 1, y));
}
if (y > 0 && field[x][y - 1] == '.' && sum(x, y - 1) == 1) {
q.push(make_pair(x, y - 1));
}
if (field[x + 1][y] == '.' && sum(x + 1, y) == 1) {
q.push(make_pair(x + 1, y));
}
if (field[x][y + 1] == '.' && sum(x, y + 1) == 1) {
q.push(make_pair(x, y + 1));
}
}
if (cur) {
cout << "Not unique";
} else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", field[i][j]);
}
printf("\n");
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=1e5+10;
ll n,m,a,b,cnt;
ll head[N],bl[N];
struct Edge{ll nxt,to;}edge[N<<1];
inline void add(ll u,ll v){edge[++cnt]=(Edge){head[u],v};head[u]=cnt;}
void dfs(ll u,ll col){
bl[u]=col;
for(ll i=head[u];i;i=edge[i].nxt){
ll v=edge[i].to;
if(bl[v]==-1) dfs(v,!col);
if(bl[v]!=!col){printf("%lld",n*(n-1)/2-m);exit(0);}
}
}
int main(){
scanf("%lld%lld",&n,&m);
for(ll i=1;i<=m;i++) scanf("%lld%lld",&a,&b),add(a,b),add(b,a);
memset(bl,-1,sizeof(bl));
dfs(1,0);
ll s1=0,s2=0;
for(ll i=1;i<=n;i++) if(bl[i]==0) s1++; else if(bl[i]==1) s2++;
printf("%lld",s1*s2-m);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const double pi = acos(-1.0);
int n, k, l;
long long dp[4020][4020], fac[4040];
int read() {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0') || (ch > '9')) {
if (ch == '-') f = -1;
ch = getchar();
}
while ((ch >= '0') && (ch <= '9')) {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
long long qpow(long long x, int y) {
long long ans = 1;
while (y) {
if (y & 1) ans = (ans * x) % 998244353;
x = (x * x) % 998244353;
y >>= 1;
}
return ans;
}
long long inv(long long x) { return qpow(x, 998244353 - 2); }
int main() {
n = read();
k = read();
l = read();
dp[0][0] = 1;
for (int i = 0; i <= n * 2; i++) {
for (int j = 0; j <= min(i, n); j++) {
dp[i + 1][j + 1] = (dp[i + 1][j + 1] + dp[i][j]) % 998244353;
dp[i + 1][j - 1] = (dp[i + 1][j - 1] + dp[i][j] * j) % 998244353;
}
}
fac[0] = 1;
for (int i = 1; i <= 4000; i++) fac[i] = (fac[i - 1] * i) % 998244353;
long long ans = 0;
for (int i = 1; i <= n * 2; i++) {
for (int j = k; j <= min(i, n); j++) {
ans = (ans +
((dp[i][j] * dp[n * 2 - i][j]) % 998244353 * fac[j]) % 998244353) %
998244353;
}
}
long long len = l * inv(n * 2 + 1) % 998244353;
ans = ans * inv(dp[n * 2][0]) % 998244353;
ans = ans * len % 998244353;
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
const long long MAXN = 600;
long long k, cnt[MAXN][MAXN], n, dp[MAXN][MAXN], dad[MAXN][MAXN], mindp, minj,
j, ji, t[MAXN];
void T(long long l, long long r) {
if (l == r) return;
for (long long i = l; i <= (l + r) / 2; i++) {
s[i] = s[r - i + l];
}
}
long long h;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> s >> k;
n = s.size();
for (long long i = 0; i < n; i++) {
h = 0;
for (long long j = 0; j <= n; j++) {
if (i + j >= n || i - j < 0) break;
if (s[i - j] != s[i + j]) h++;
cnt[i - j][i + j] = h;
}
}
for (long long i = 1; i < n; i++) {
h = 0;
for (long long j = 0; j <= n; j++) {
if (i - j - 1 < 0 || i + j >= n) break;
if (s[i - j - 1] != s[i + j]) h++;
cnt[i - j - 1][i + j] = h;
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j <= k; j++) {
if (j <= 1 || i == 0) {
dp[i][j] = cnt[0][i];
dad[i][j] = -1;
continue;
}
dp[i][j] = 510;
dad[i][j] = -1;
if (i + 1 < j) break;
for (long long d = 0; d < i; d++) {
if (dp[i][j] > dp[d][j - 1] + cnt[d + 1][i]) {
dp[i][j] = dp[d][j - 1] + cnt[d + 1][i];
dad[i][j] = d;
}
}
}
}
mindp = 510;
for (long long j = 1; j <= k; j++)
if (dp[n - 1][j] < mindp) {
mindp = dp[n - 1][j];
minj = j;
}
j = minj;
ji = j;
t[0] = -1;
long long x = n - 1;
while (ji > 1) {
if (dad[x][ji] == -1) break;
x = dad[x][ji];
t[ji - 2] = x;
ji--;
}
x = 0;
cout << mindp << endl;
for (long long i = 0; i < j - ji; i++) {
T(x, t[i]);
x = t[i] + 1;
}
T(x, n - 1);
ji = 0;
for (long long i = 0; i < s.size(); i++) {
cout << s[i];
if (t[ji] == i) cout << "+", ji++;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
vector<int> g[N];
int sub[N];
int centlvl[N];
int p[N];
char s[N];
int ma[N];
int dfs(int u, int last, int d) {
sub[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v != last) {
p[v] = u;
sub[u] += dfs(v, u, d + 1);
}
}
return sub[u];
}
void cent_decomp(int root, int lvl) {
int cur = root;
bool done = false;
while (!done) {
int nxt = -1;
for (int i = 0; i < g[cur].size(); i++) {
int v = g[cur][i];
if (p[v] == cur and centlvl[v] == -1) {
if (nxt == -1 or sub[v] > sub[nxt]) nxt = v;
}
}
if (nxt == -1 or sub[nxt] <= sub[root] / 2)
done = true;
else
cur = nxt;
}
int c = cur;
centlvl[c] = lvl;
while (cur != root) {
sub[p[cur]] -= sub[c];
cur = p[cur];
}
for (int i = 0; i < g[c].size(); i++) {
int v = g[c][i];
if (centlvl[v] != -1) continue;
if (p[v] == c)
cent_decomp(v, lvl + 1);
else
cent_decomp(root, lvl + 1);
}
}
long long ans[N];
int vis[N], vflag;
int mask_count[1 << 20], mask_stamp[1 << 20], mflag;
long long path_count[N];
long long dfs_ans(int u, int c, int m) {
if (centlvl[u] <= centlvl[c]) return 0;
if (vis[u] == vflag) return 0;
vis[u] = vflag;
path_count[u] = mask_stamp[m] == mflag ? mask_count[m] : 0;
for (int i = 0; i < 20; i++) {
int mm = m ^ (1 << i);
path_count[u] += mask_stamp[mm] == mflag ? mask_count[mm] : 0;
}
for (int v : g[u]) path_count[u] += dfs_ans(v, c, m ^ ma[v]);
if (__builtin_popcount(m) <= 1) path_count[u]++;
ans[u] += path_count[u];
return path_count[u];
}
void dfs_cnt(int u, int c, int m, int sgn) {
if (centlvl[u] <= centlvl[c]) return;
if (vis[u] == vflag) return;
vis[u] = vflag;
if (mask_stamp[m] != mflag) {
mask_stamp[m] = mflag;
mask_count[m] = 0;
}
mask_count[m] += sgn;
for (int v : g[u]) dfs_cnt(v, c, m ^ ma[v], sgn);
}
int main() {
memset(centlvl, -1, sizeof(centlvl));
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
scanf("%s", s);
for (int i = 1; i <= n; i++) {
ma[i] = 1 << (s[i - 1] - 'a');
ans[i] = 1;
}
dfs(1, -1, 0);
cent_decomp(1, 0);
for (int c = 1; c <= n; c++) {
mflag++;
for (int v : g[c]) {
vflag++;
dfs_cnt(v, c, ma[v], 1);
}
long long c_paths = 0;
for (int v : g[c]) {
vflag++;
dfs_cnt(v, c, ma[v], -1);
vflag++;
c_paths += dfs_ans(v, c, ma[v] ^ ma[c]);
vflag++;
dfs_cnt(v, c, ma[v], 1);
}
c_paths += mask_stamp[ma[c]] == mflag ? mask_count[ma[c]] : 0;
for (int i = 0; i < 20; i++) {
int mm = ma[c] ^ (1 << i);
c_paths += mask_stamp[mm] == mflag ? mask_count[mm] : 0;
}
c_paths /= 2;
ans[c] += c_paths;
}
for (int i = 1; i <= n; i++) {
printf("%lld%c", ans[i], " \n"[i == n]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename P>
P dectobin(P a) {
if (a == 0)
return 0;
else
return (a % 2 + 10 * dectobin(a / 2));
}
template <typename Y>
Y bintodec(Y a) {
long long ans = 0, b = 1, t = a;
while (t) {
long long ld = t % 10;
t /= 10;
ans += ld * b;
b = b * 2;
}
return ans;
}
template <typename H>
H modExp(H x, H n) {
long long r = 1;
while (n > 0) {
if (n % 2 == 1) {
r = (r * x) % 1000000007;
}
x = (x * x) % 1000000007;
n /= 2;
}
return r;
}
template <typename T>
T isPowerOfTwo(T x) {
return x && (!(x & (x - 1)));
}
template <typename T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ostream_iterator<long long> output(cout, " ");
long long t;
cin >> t;
while (t--) {
long long n, cnt1 = 0, cnt2 = 0;
cin >> n;
string second;
cin >> second;
for (long long(i) = (0); i < (n); i++) {
if (second[i] != '>')
cnt1++;
else
break;
}
for (long long i = n - 1; i >= 0; i--) {
if (second[i] != '<')
cnt2++;
else
break;
}
if (n == 2) {
if (cnt1 == 1 && cnt2 == 1) {
cout << 1 << '\n';
} else {
cout << 0 << '\n';
}
} else if (n == 1) {
cout << 0 << '\n';
} else {
if (cnt1 == 0 || cnt2 == 0)
cout << 0 << '\n';
else
cout << min(cnt1, cnt2) << '\n';
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int C = 26;
void add(int &x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
int mul(int a, int b) { return (long long)a * b % MOD; }
const int MAXN = 1e6 + 10;
int fact[MAXN], finv[MAXN];
int binom(int a, int b) {
if (a < b) return 0;
return mul(fact[a], mul(finv[a - b], finv[b]));
}
int n, A, h[MAXN];
void solve() {
fact[0] = 1;
for (int i = 1; i < MAXN; i++) fact[i] = mul(i, fact[i - 1]);
finv[MAXN - 1] = pw(fact[MAXN - 1], MOD - 2);
for (int i = MAXN - 2; ~i; --i) finv[i] = mul(i + 1, finv[i + 1]);
cin >> n >> A;
for (int i = 0; i < n; i++) cin >> h[i];
if (A == 1) {
cout << "0\n";
return;
}
int ans = 0;
int dont_care = 0;
for (int i = 0; i < n; i++)
if (h[i] == h[(i + 1) % n]) ++dont_care;
int care = n - dont_care, ways = 0;
for (int total = 1; total <= care; total++) {
int coef = mul(binom(care, total), pw(A - 2, care - total));
if (total % 2 == 1) {
ways = fix(pw(2, total - 1));
} else {
ways = mul(pw(2, MOD - 2), fix(pw(2, total) - binom(total, total / 2)));
}
add(ans, mul(coef, ways));
}
ans = mul(ans, pw(A, dont_care));
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n; cin >> n;
map<string, int> mp;
for (int i = 0; i < n; i++) {
string s; cin >> s;
mp[s]++;
}
int m; cin >> m;
for (int i = 0; i < m; i++) {
string s; cin >> s;
mp[s]--;
}
int ans = 0;
for (auto i = mp.begin(); i != mp.end(); i++) {
ans = max(ans, mp[i->first]);
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n), b(n);
long long maxto = 1e9;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
bool flag = true;
maxto = a[0];
for (long long i = 0; i < n; i++) {
cin >> b[i];
if (i == n - 1) {
continue;
}
if (i == 0) {
long long e = min(a[i + 1], b[i]);
a[i + 1] -= e;
a[i] -= min(a[i], (b[i] - e));
maxto = min(maxto, min(e, a[0]));
} else {
if (a[i] - b[i] > 0) {
flag = false;
}
long long e = min(a[i], b[i]);
a[i] -= e;
long long t = min(b[i] - e, a[i + 1]);
a[i + 1] -= t;
if (t < b[i] - e) {
a[0] -= min(maxto, b[i] - e - t);
maxto -= min(maxto, b[i] - e - t);
}
maxto = min(maxto, t);
}
}
if (!flag || b[n - 1] < a[0] + a[n - 1]) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
return 0;
}
| 6 |
Subsets and Splits