solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <cstdio>
int main (int argc, char const* argv[])
{
int a=0,b,i;
while(true){
for(i=0;i<10;i++){
scanf("%d",&b);
if(i)a-=b;
else if(b) a=b;
else break;
}
if(i==0) break;
printf("%d\n",a);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " = " << a << endl;
err(++it, args...);
}
const long long MOD = 1e9 + 7;
long long modExp(long long b, long long p) {
long long res = 1;
while (p > 0) {
if (p & 1) {
res = (res * b) % MOD;
}
b = (b * b) % MOD;
p >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
long long ans = 1;
for (int i = 1; i <= n; i++) {
ans = ((2 * m - 1) * ans + modExp(m, i - 1)) % MOD;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 1e4 + 5, OO = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int main() {
int q;
cin >> q;
while (q--) {
int c, m, x;
cin >> c >> m >> x;
int ans = 0;
int d = max(c, m) - min(c, m);
if (max(c, m) == c)
c -= d;
else
m -= d;
x += d;
int mn = min(c, min(m, x));
c -= mn, m -= mn, x -= mn;
ans = mn + (c + m) / 3;
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cases;
cin >> cases;
while (cases--) {
int mx1 = 0, mx2 = 0;
int card, f, s;
cin >> card >> f >> s;
while (f--) {
int x;
cin >> x;
mx1 = max(mx1, x);
}
while (s--) {
int x;
cin >> x;
mx2 = max(mx2, x);
}
if (mx1 > mx2)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 1 |
#include <iostream>
#include <cstdio>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <string>
#include <cstring>
#include <cmath>
#include <complex>
#include <map>
#include <climits>
#include <sstream>
using namespace std;
#define reep(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) reep((i),0,(n))
#define ALL(v) (v).begin(),(v).end()
#define PB push_back
#define EPS 1e-8
#define F first
#define S second
#define mkp make_pair
static const double PI=6*asin(0.5);
typedef long long ll;
typedef complex<double> CP;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vint;
static const int INF=1<<24;
template <class T>
void initvv(vector<vector<T> > &v,int a,int b, const T &t = T()){
v.assign(a,vector<T>(b,t));
}
//v.erase(unique(v.begin(),v.end()),v.end());
long double foo(long double a,long double b){
long double s=a/2.0+b;
long double ret=sqrt(s*(s-a)*(s-b)*(s-b));
return ret;
}
int main(){
long double a,l,x;
while(cin>>a>>l>>x){
long double ans=foo(a,l);
ans+=foo(l,(l+x)/2.0)*2.0;
printf("%.10Lf\n",ans);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, step;
scanf("%d%d%d%d", &n, &m, &k, &step);
int a[n][m];
long long s[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
s[i][j] = a[i][j];
if (i) s[i][j] += s[i - 1][j];
if (j) s[i][j] += s[i][j - 1];
if (i && j) s[i][j] -= s[i - 1][j - 1];
}
priority_queue<int> q;
long long dp1[k + 1], dp2[k + 1];
dp1[0] = dp2[0] = 0;
for (int i = 0; i < n; i++) {
long long tmp = s[i][m - 1];
if (i) tmp -= s[i - 1][m - 1];
q.push(tmp);
}
for (int i = 1; i <= k; i++) {
long long x = q.top();
q.pop();
dp1[i] = dp1[i - 1] + x;
q.push(x - m * step);
}
for (; !q.empty(); q.pop())
;
for (int j = 0; j < m; j++) {
long long tmp = s[n - 1][j];
if (j) tmp -= s[n - 1][j - 1];
q.push(tmp);
}
for (int i = 1; i <= k; i++) {
long long x = q.top();
q.pop();
dp2[i] = dp2[i - 1] + x;
q.push(x - n * step);
}
long long ans = max(dp1[k], dp2[k]);
for (int i = 1; i < k; i++) {
long long tmp = dp1[i] + dp2[k - i];
tmp -= (long long)i * step * (k - i);
ans = max(ans, tmp);
}
printf("%I64d", ans);
exit(0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
int n;
string s;
int f[N], sum[N];
int nxt[N][3], eq[N];
void add(int &x,int y) {
x += y; if (x >= mod) x -= mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> s; n = s.size(); s = '~' + s;
for (int i = 1; i <= n; ++i) {
sum[i] = (sum[i - 1] + (s[i] == 'a' ? 1 : 2)) % 3;
}
for (int i = 0; i < 3; ++i) nxt[n + 1][i] = n + 1;
for (int i = n; i >= 1; --i) {
for (int j = 0; j < 3; ++j) {
nxt[i][j] = nxt[i + 1][j];
}
nxt[i][sum[i]] = i;
}
eq[n] = n;
for (int i = n - 1; i >= 1; --i) {
if (s[i] == s[i + 1]) eq[i] = i;
else eq[i] = eq[i + 1];
}
if (eq[1] == n) return cout << 1 << '\n',0;
f[0] = 1;
for (int i = 0; i < n; ++i) {
for (int t = 1; t <= 2; ++t) {
int want = (sum[i] + t) % 3;
if (sum[i + 1] == want) add(f[i + 1], f[i]);
else {
int pos = nxt[eq[i] + 1][want];
if (pos <= n) add(f[pos], f[i]);
}
}
}
int res = 0;
for (int i = 1; i <= n; ++i) if (sum[i] == sum[n]) add(res, f[i]);
cout << res << '\n';
}
| 0 |
#include <bits/stdc++.h>
const int kMaxSize = 2000 + 10;
const int kDiv = 1000000000 + 7;
int n, m;
long long f[kMaxSize][kMaxSize], s[kMaxSize][kMaxSize];
void Initialize() {
int i, j, k;
for (i = 2; i <= m; ++i) {
f[1][i] = 1;
s[1][i] = s[1][i - 1] + f[1][i];
}
for (i = 2; i <= n; ++i) {
for (j = 2; j <= m; ++j) {
f[i][j] = (f[i][j - 1] + s[i - 1][j]) % kDiv;
s[i][j] = (s[i][j - 1] + f[i][j]) % kDiv;
}
}
memset(s, 0, sizeof(s));
for (i = 1; i <= n; ++i)
for (j = 2; j <= m; ++j) s[i][j] = (s[i - 1][j] + f[i][j]) % kDiv;
}
int main() {
scanf("%d %d", &n, &m);
Initialize();
long long result = 0;
for (int i = 1; i <= n; ++i)
for (int j = 2; j <= m; ++j)
result = (result + ((s[i][j] * (s[n + 1 - i][j] - s[n - i][j])) % kDiv) *
(m + 1 - j)) %
kDiv;
printf("%I64d\n", result);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, b, start = 1, co = 1, su = 1;
scanf("%lld %lld", &n, &a);
for (int i = 1; i <= n; i++) start = (start * 2);
start -= 1;
while (2 * a - 1 != start) {
start = start / 2;
if (start < a) {
a -= (start + 1);
}
--n;
}
cout << n << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, x1, x2, y1, y2;
double res = 0, r1, r2;
cin >> n >> k;
cin >> x1 >> y1;
for (i = 1; i < n; i++) {
cin >> x2 >> y2;
r1 = (double)(x2 - x1) * (x2 - x1);
r2 = (double)(y2 - y1) * (y2 - y1);
res += sqrt(r1 + r2);
x1 = x2;
y1 = y2;
}
res /= 50;
res *= k;
printf("%.9lf\n", res);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100005;
int n, k;
unsigned int ip[Maxn];
set<unsigned int> S;
int toInt(const string &s) {
stringstream ss(s);
int res;
ss >> res;
return res;
}
unsigned int getUint(const string &s) {
unsigned int res = 0;
int v = s.find('.');
res = toInt(s.substr(0, v)) << 24;
int u = s.find('.', v + 1);
res += toInt(s.substr(v + 1, u - v - 1)) << 16;
v = u;
u = s.find('.', v + 1);
res += toInt(s.substr(v + 1, u - v - 1)) << 8;
v = u;
res += toInt(s.substr(v + 1));
return res;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
string s;
cin >> s;
ip[i] = getUint(s);
}
int i;
for (i = 1; i <= 31; i++) {
unsigned int mask = (1 << i) - 1 << 32 - i;
S.clear();
for (int j = 0; j < n; j++) S.insert(ip[j] & mask);
if (S.size() == k) break;
}
if (i <= 31) {
unsigned int mask = (1 << i) - 1 << 32 - i;
printf("%d.%d.%d.%d\n", mask / (1 << 24), mask % (1 << 24) / (1 << 16),
mask % (1 << 16) / (1 << 8), mask % (1 << 8));
} else
printf("-1\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void c_p_c() {}
long long maxSubArraySum(long long a[], long long size) {
long long max_so_far = INT_MIN, max_ending_here = 0, start = 0, end = 0,
s = 0;
for (long long i = 0; i < size; i++) {
max_ending_here += a[i];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0) {
max_ending_here = 0;
s = i + 1;
}
}
return 1;
}
long long isPrime(long long n) {
long long a = 0;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
long long bigpower(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) {
res *= a;
}
a *= a;
b >>= 1;
}
return res;
}
long long fact(long long n) {
long long a = 1;
for (long long i = 1; i <= n; i++) {
a *= i;
}
return a;
}
struct cmp {
bool operator()(const pair<long long, long long> &a,
const pair<long long, long long> &b) const {
long long la = a.second - a.first + 1;
long long lb = b.second - b.first + 1;
if (la == lb) return a.first < b.first;
return la > lb;
}
};
bool how(pair<long long, long long> a, pair<long long, long long> b) {
return a.first > b.first;
}
const long long N = 200100;
long long a[N];
long long freq[N];
long long n;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
c_p_c();
long long n, m;
cin >> n >> m;
long long a[m];
map<long long, long long> occ;
set<long long> s;
for (long long i = 0; i < m; i++) {
cin >> a[i];
occ[a[i]]++;
s.insert(a[i]);
if (s.size() == n) {
cout << 1;
s.clear();
for (long long i = 1; i <= n; i++) {
occ[i]--;
if (occ[i]) s.insert(i);
}
} else
cout << 0;
}
cout << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int N;
int P[201010];
int D[202020];
int VD[202020];
vector<int> E[202020];
ll p2[202020];
ll mo=1000000007;
deque<vector<ll>> dp[202020];
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>N;
VD[0]++;
FOR(i,N) {
cin>>P[i+1];
E[P[i+1]].push_back(i+1);
D[i+1]=D[P[i+1]]+1;
VD[D[i+1]]++;
}
N++;
p2[0]=1;
FOR(i,N) p2[i+1]=p2[i]*2%mo;
for(i=N-1;i>=0;i--) {
FORR(e,E[i]) {
if(dp[e].size()>dp[i].size()) swap(dp[e],dp[i]);
}
int ma=0;
FORR(e,E[i]) {
ma=max(ma,(int)dp[e].size());
FOR(j,dp[e].size()) {
ll a[3]={};
a[0]=dp[i][j][0]*dp[e][j][0]%mo;
a[1]=(dp[i][j][0]*dp[e][j][1]+dp[i][j][1]*dp[e][j][0])%mo;
a[2]=(dp[i][j][2]*(dp[e][j][0]+dp[e][j][1])+dp[i][j][1]*dp[e][j][1])%mo;
dp[i][j][0]=a[0];
dp[i][j][1]=a[1];
dp[i][j][2]=a[2];
}
}
FOR(j,ma) {
(dp[i][j][0]+=dp[i][j][2])%=mo;
dp[i][j][2]=0;
}
dp[i].push_front({1,1,0});
}
ll ret=0;
FOR(i,dp[0].size()) ret+=dp[0][i][1]*p2[N-VD[i]]%mo;
cout<<ret%mo<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int MOD = 1000000007;
int ans[N + 11][N + 11], C[N + 11][N + 11];
int f[N + 11];
int main() {
for (int i = 0; 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;
}
}
f[0] = 1;
for (int k = 1; k <= N; k++) {
if (k * (k - 1) / 2 > N) continue;
long long fac = 1;
for (int i = 1; i <= k; i++) {
fac *= i;
fac %= MOD;
}
for (int i = N; i >= 0; i--) {
for (int times = 1; times * k + i <= N; times++) {
(f[i + times * k] += f[i]) %= MOD;
}
}
for (int n = 0; n <= N; n++) {
int tot = k * (k - 1) / 2;
ans[n][k] = 0;
int nn = n - tot;
for (int x = 0; x <= nn; x++) {
(ans[n][k] += 1LL * f[x] * fac % MOD * C[nn - x + 1][k] % MOD) %= MOD;
}
}
}
int test;
scanf("%d", &test);
while (test--) {
int n, k;
scanf("%d %d", &n, &k);
printf("%d\n", ans[n - 1][k]);
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
const int maxi=1e6;
int lev,rez,n,sum,x,y;
vector<int> v[maxi];
int pr[maxi];
void dfs(int x, int pred)
{
lev++;
sum++;
pr[x]=pred;
if (x==n) rez=lev;
for (int i:v[x])
if (i!=pred) dfs(i,x);
lev--;
}
int main()
{
cin>>n;
for (int i=1;i<n;i++)
{
scanf("%d%d",&x,&y);
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1,0);
rez-=2;
rez/=2;
x=n;
while(rez>0)
{
x=pr[x];
rez--;
}
sum=0;
dfs(x,pr[x]);
if (sum<n-sum) printf("Fennec\n"); else printf("Snuke\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int d, x, y;
void extendedEuclid(int A, int B) {
if (B == 0) {
d = A;
x = 1;
y = 0;
} else {
extendedEuclid(B, A % B);
int temp = x;
x = y;
y = temp - (A / B) * y;
}
}
int main() {
int n;
cin >> n;
while (true) {
if (n < 0) {
cout << "-1" << endl;
return 0;
}
if (n % 7 == 0) {
y = n / 7;
break;
}
n -= 4;
x++;
}
for (int i = 0; i < x; i++) cout << "4";
for (int i = 0; i < y; i++) cout << "7";
cout << endl;
}
| 1 |
#include<iostream>
#include<stack>
#include<algorithm>
using namespace std;
typedef pair<int, int> P;
int W, H;
int vx[4] = { 0,-1,0,1 }, vy[4] = { 1,0,-1,0 };
int filed[50][50];
bool usedB[50][50], usedW[50][50];
void dfs(P start, int flg) {
stack<P> s;
s.push(start);
while (s.size()) {
auto now = s.top(); s.pop();
for (int i = 0; i < 4; i++) {
int nx = now.first + vx[i], ny = now.second + vy[i];
if (nx < 0 || ny < 0 || nx >= H || ny >= W)continue;
if (!flg) {
if (usedW[nx][ny])continue;
if (filed[nx][ny] != 0)continue;
usedW[nx][ny] = true;
s.push(P(nx, ny));
}else {
if (usedB[nx][ny])continue;
if (filed[nx][ny] != 0)continue;
usedB[nx][ny] = true;
s.push(P(nx, ny));
}
}
}
}
int main() {
while (1) {
cin >> W >> H;
if (W + H == 0)break;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
char c;
cin >> c;
if (c == 'W')filed[i][j] = 1;
else if (c == 'B')filed[i][j] = 2;
else filed[i][j] = 0;
usedB[i][j] = false;
usedW[i][j] = false;
}
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (filed[i][j] == 1) {
dfs(P(i, j), 0);
}
else if (filed[i][j] == 2) {
dfs(P(i, j), 1);
}
}
}
int ansB = 0, ansW = 0;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (usedW[i][j] && !usedB[i][j])ansW++;
if (usedB[i][j] && !usedW[i][j])ansB++;
}
}
cout << ansB << " " << ansW << endl;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=200010, M=1e9+7;
int t, n, k, a[N];
vector<int> Pri;
int main(){
cin>>t;
while (t){
t--;
scanf("%d", &n);
for (int i=0; i<n; i++) scanf("%d", a+i);
int tot=a[0];
for (int i=1; i<n; i++) tot&=a[i];
long long ans=0;
for (int i=0; i<n; i++) ans+=(a[i]==tot);
if (ans<2) printf("0\n");
else{
ans=ans*(ans-1) % M;
for (int i=1; i<=n-2; i++) ans=ans*i % M;
printf("%lld\n", ans);
}
}
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int nmax = 500010;
long long res, cnt = 1e+9 + 7;
long double eps = 1e-6;
long long n, l, r, x, y, c, d, a, b, m;
int main() {
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
scanf("%lld%lld", &n, &x);
for (int i = 0; i < n; ++i) {
scanf("%lld", &l);
res += min(b, a * l);
}
res = min(res, c);
for (int i = 0; i < x; ++i) {
scanf("%lld", &l);
r += min(b, a * l);
}
res += min(r, c);
res = min(res, d);
printf("%lld", res);
return 0;
}
| 2 |
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
using namespace std;
#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=b; ++i)
#define FORR(i,a,b) for (int i=a; i>=b; --i)
#define pi M_PI
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
int main() {
string s, t, s1, s2;
cin >> s >> t;
REP(i,s.length()){
if (i % 2 == 0) s1 += s[i];
else s2 += s[i];
}
int j1 = 0, j2 = 0;
for (int i=0; i < t.length() && j1 < s1.length() && j2 < s2.length(); i++){
if (t[i] == s1[j1]) j1++;
if (t[i] == s2[j2]) j2++;
}
if (j1 == s1.length() || j2 == s2.length()) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int degree[200001];
struct MNode {
int x;
int y;
MNode() {}
MNode(int a, int b) : x(a), y(b) {}
bool operator==(MNode &b) const { return x == b.x && y == b.y; }
bool operator<(MNode b) const { return x < b.x || (x == b.x && y < b.y); }
};
bool cmp1(MNode &a, MNode &b) {
return (a.x < b.x || (a.x == b.x && a.y < b.y));
}
bool cmp2(const MNode &a, const MNode &b) {
return (a.y < b.y || (a.y == b.y && a.x < b.x));
}
int n, m;
multiset<int> result;
set<MNode> M;
void star(int i, const set<int> &u, set<int> &ai, set<int> &mi) {
ai = u;
mi.clear();
for (set<MNode>::iterator it = M.lower_bound(MNode(i, 0));
it != M.upper_bound(MNode(i + 1, 0)); it++) {
if (it->x == i && u.find(it->y) != u.end()) {
mi.insert(it->y);
ai.erase(it->y);
}
}
}
int CountM(const set<int> &u) {
int c = 0;
for (set<MNode>::iterator it = M.begin(); it != M.end(); it++) {
if (u.find(it->x) != u.end() && u.find(it->y) != u.end()) c++;
}
c /= 2;
}
void UpdateDegree(const set<int> &u, int &dmin, int &dmax) {
for (int i = 1; i <= n; i++) degree[i] = (i - 1);
for (set<MNode>::iterator it = M.begin(); it != M.end(); it++) {
if (u.find(it->x) != u.end()) degree[it->x]--;
}
dmin = 0x7fffffff;
dmax = 0;
for (int i = 1; i <= n; i++) {
if (degree[i] < dmin) dmin = degree[i];
if (degree[i] > dmax) dmax = degree[i];
}
}
void UpdateMNode(const set<int> &u) {
for (set<MNode>::iterator it = M.begin(); it != M.end();) {
if (u.find(it->x) == u.end() || u.find(it->y) == u.end())
M.erase(it++);
else
it++;
}
}
int parent[200001], coun[200001];
void InitUF() {
for (int i = 1; i <= n; i++) {
parent[i] = i;
coun[i] = 1;
}
}
int Find(int x) { return (parent[x] == x) ? x : (parent[x] = Find(parent[x])); }
void Union(int x, int y) {
int i = Find(x);
int j = Find(y);
if (i != j) {
if (coun[i] < coun[j]) {
parent[i] = j;
coun[j] += coun[i];
} else {
parent[j] = i;
coun[i] += coun[j];
}
}
}
void DSU(set<int> &u) {
int a[700][700];
int i, j, ii[700];
map<int, int> mp;
i = 1;
for (set<int>::iterator it = u.begin(); it != u.end(); it++) {
mp.insert(pair<int, int>(*it, i));
ii[i++] = *it;
}
memset(a, 0, sizeof(a));
for (set<MNode>::iterator it = M.begin(); it != M.end(); it++) {
if (it->x < it->y && u.find(it->x) != u.end() && u.find(it->y) != u.end()) {
map<int, int>::iterator itm;
i = mp.find(it->x)->second;
j = mp.find(it->y)->second;
a[i][j] = a[j][i] = 1;
}
}
InitUF();
for (int i = 1; i <= u.size(); i++) {
int x = ii[i];
for (int j = i + 1; j <= u.size(); j++) {
int y = ii[j];
if (a[i][j] == 0) Union(x, y);
}
}
for (set<int>::iterator it = u.begin(); it != u.end(); it++)
if (parent[*it] == *it) result.insert(coun[*it]);
}
int main() {
int a, b;
set<int> u, s, t, r, tmp;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
if (a != b) {
M.insert(MNode(a, b));
M.insert(MNode(b, a));
}
}
m = M.size() / 2;
int dmin, dmax;
for (int i = 1; i <= n; i++) u.insert(i);
do {
UpdateMNode(u);
UpdateDegree(u, dmin, dmax);
if (u.size() < 700) {
DSU(u);
break;
}
set<int>::iterator it, it0 = u.begin();
for (it = u.begin(); it != u.end(); it++) {
if (degree[*it] > degree[*it0]) it0 = it;
}
star(*it0, u, s, r);
bool update;
do {
update = false;
for (set<int>::iterator it = r.begin(); it != r.end(); it++) {
set<int> r1;
star(*it, u, t, r1);
if (s.find(*it) != s.end())
set_union(s.begin(), s.end(), t.begin(), t.end(),
inserter(s, s.begin()));
else {
tmp.clear();
set_intersection(s.begin(), s.end(), t.begin(), t.end(),
inserter(tmp, tmp.begin()));
if (!tmp.empty()) {
update = true;
set_union(s.begin(), s.end(), t.begin(), t.end(),
inserter(s, s.begin()));
}
}
}
if (update) {
r.clear();
set_difference(u.begin(), u.end(), s.begin(), s.end(),
inserter(r, r.begin()));
}
} while (update);
result.insert(s.size());
if (r.empty()) break;
u = r;
} while (1);
printf("%d\n", result.size());
for (multiset<int>::iterator it = result.begin(); it != result.end(); it++)
printf("%d ", *it);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int p[360];
int main() {
int n, i, a = 0, b, sum, ret = INT_MAX;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", p + i);
b = 0;
sum = p[0];
while (a < n) {
while (sum < 180) {
b = (b + 1) % n;
sum += p[b];
}
ret = min(ret, 2 * sum - 360);
sum -= p[a];
a++;
}
printf("%d", ret);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
long long i;
vector<long long> v;
long long p = s.length();
long long pp = 0;
for (i = 0; i <= p - 1; i++) {
if (s[i] != 'a') {
v.push_back(i);
pp++;
}
}
long long x = 1;
vector<long long> v2;
map<long long, long long> m;
for (i = pp - 2; i >= 0; i--) {
if (v[i + 1] - v[i] == 1) {
x++;
} else {
v2.push_back(x);
m[x] = v[i + 1];
x = 1;
}
}
v2.push_back(x);
if (pp != 0) {
m[x] = v[0];
}
sort(v2.rbegin(), v2.rend());
if (pp != 0) {
for (i = m[x]; i <= m[x] + (x - 1); i++) {
s[i] = s[i] - 1;
}
} else {
for (i = p - 1; i <= p - 1; i++) {
s[i] = 'z';
}
}
cout << s << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 25);
int C, D, W, X;
int E[16][32], F[16][32];
int dp[32][64][8];
int solve(int d, int w, int x)
{
if(w > W || x > X) return -inf;
if(d == D) return 0;
if(~dp[d][w][x]) return dp[d][w][x];
int ret = solve(d+1, w, x);
for(int i = 0; i < C; i++){
int le = 0, lf = 0, re = 0, rf = 0;
for(int j = 0; j < C; j++){
if(i - j >= 0 && le >= 0){
le += E[i-j][d], lf += F[i-j][d];
ret = max(ret, solve(d+1, w+lf, x+(j!=0)) + le);
}
if(i + j < C && re >= 0){
re += E[i+j][d], rf += F[i+j][d];
ret = max(ret, solve(d+1, w+rf, x+(j!=0)) + re);
}
}
}
return dp[d][w][x] = ret;
}
int main()
{
while(cin >> C >> D >> W >> X, C || D || W || X){
memset(E, 0, sizeof(E));
memset(F, 0, sizeof(F));
for(int i = 0; i < C; i++){
for(int j = 0; j < D; j++) cin >> E[i][j], E[i][j] = (E[i][j] == 0 ? -inf : E[i][j]);
}
for(int i = 0; i < C; i++){
for(int j = 0; j < D; j++) cin >> F[i][j], F[i][j] = (E[i][j] == -inf ? inf : F[i][j]);
}
memset(dp, -1, sizeof(dp));
cout << solve(0, 0, 0) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int a[50] = {};
int main() {
string s;
int k;
cin >> s >> k;
for (int i = 0; i < s.length(); i++) a[s[i] - 'a']++;
int sum = 0, cnt = 0;
for (int i = 0; i < 30; i++) {
if (a[i] > 0) cnt++;
sum += a[i];
}
if (sum < k) return puts("impossible"), 0;
if (cnt >= k) return puts("0"), 0;
cout << k - cnt << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, string> a, pair<int, string> b) { return a.first < b.first; }
int main() {
vector<pair<int, string>> v;
string s, x;
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x;
v.emplace_back(x.size(), x);
}
sort(v.begin(), v.end(), cmp);
cin >> s;
int best = 0, cnta = 0, cntb = 0, worst = 0;
for (int i = 0; i < n; i++) {
if (v[i].first < s.size()) {
best++;
cnta++;
if (cnta == k) {
best += 5;
cnta = 0;
}
} else if (v[i].first == s.size() && v[i].second != s) {
worst++;
cnta++;
if (cnta == k) {
worst += 5;
cnta = 0;
}
} else if (v[i].first > s.size()) {
break;
}
}
cout << best + 1 << " " << best + worst + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
const int K = 16;
long long S[K];
long long edg[N * K], A[N * K], BX[N * K], poss[1 << (K - 1)];
vector<pair<int, int>> lol[1 << (K - 1)];
pair<int, int> L[1 << (K - 1)];
map<long long, int> bx;
int main() {
memset(edg, -1, sizeof(edg));
int k;
scanf("%d", &k);
long long V = 0;
int nd = 0;
for (int i = 1; i <= k; ++i) {
int n;
scanf("%d", &n);
for (int j = 1; j <= n; ++j) {
++nd;
int x;
scanf("%d", &x);
A[nd] = x;
V += x;
S[i] += x;
BX[nd] = i;
bx[x] = nd;
}
}
if (V % k != 0) {
puts("no");
return 0;
}
V /= k;
for (int i = 1; i <= nd; ++i) {
long long y = V - (S[BX[i]] - A[i]);
if (bx.count(y)) edg[i] = bx[y];
}
vector<int> vis(nd + 1);
vector<pair<int, int>> cyc;
int z = 0;
function<pair<int, int>(int)> haku = [&](int s) -> pair<int, int> {
if (vis[s] == z) return {s, 1};
if (vis[s]) return {0, 0};
vis[s] = z;
if (edg[s] != -1) {
auto u = haku(edg[s]);
if (u.second) {
if (u.second) cyc.emplace_back(s, edg[s]);
if (u.first == s) u.second = 0;
}
return u;
}
return {0, 0};
};
for (int i = 1; i <= nd; ++i) {
if (!vis[i]) {
cyc.clear();
++z;
auto u = haku(i);
if (cyc.empty()) continue;
int m = 0, ok = 1;
for (auto u : cyc) {
if (m & (1 << (BX[u.first] - 1))) ok = 0;
m |= 1 << (BX[u.first] - 1);
}
if (ok == 0) continue;
poss[m]++;
lol[m] = cyc;
}
}
for (int i = 1; i < (1 << k); ++i) {
if (poss[i]) {
L[i] = {-1, -1};
continue;
}
for (int j = (i - 1) & i; j; j = (j - 1) & i) {
if (poss[j] && poss[j ^ i]) {
L[i] = {j, j ^ i};
poss[i] = 1;
break;
}
}
}
if (!poss[(1 << k) - 1]) {
puts("no");
return 0;
}
puts("yes");
vector<pair<int, int>> res(k + 1);
function<void(int)> H = [&](int s) {
if (L[s].first == -1) {
for (auto [x, y] : lol[s]) {
res[BX[y]] = {A[y], BX[x]};
}
return;
}
H(L[s].first);
H(L[s].second);
};
H((1 << k) - 1);
for (int i = 1; i <= k; ++i) {
printf("%d %d\n", res[i].first, res[i].second);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int f = 1;
int x;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
return x;
}
vector<long long> u;
vector<long long> p;
vector<long long> rs;
int main() {
long long a, b, c;
long long m;
cin >> a >> b >> c >> m;
for (int i = 0; i < m; i++) {
long long t;
string s;
cin >> t >> s;
if (s[0] == 'P') {
p.push_back(t);
} else {
u.push_back(t);
}
}
sort(p.begin(), p.end());
sort(u.begin(), u.end());
long long num = min(a, (long long)u.size()) + min(b, (long long)p.size());
long long ans = 0;
for (int i = 0; i < u.size(); i++) {
if (i >= a) {
rs.push_back(u[i]);
} else {
ans += u[i];
}
}
for (int i = 0; i < p.size(); i++) {
if (i >= b) {
rs.push_back(p[i]);
} else {
ans += p[i];
}
}
sort(rs.begin(), rs.end());
num += min((long long)rs.size(), c);
for (int i = 0; i < min((long long)rs.size(), c); i++) {
ans += rs[i];
}
cout << num << " " << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> v(n);
vector<int> used(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int c = 0;
int d = 0;
int ans = 0;
while (c < n) {
if (d == 0) {
for (int i = 0; i < n; i++) {
if (!used[i] && v[i] <= c) {
used[i] = 1;
c++;
}
}
} else {
for (int i = n - 1; i >= 0; i--) {
if (!used[i] && v[i] <= c) {
used[i] = 1;
c++;
}
}
}
d ^= 1;
if (c < n) ans++;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
string t;
cin >> t;
int increment = 1;
for (int i = 0; i < n; i += increment, increment++) {
cout << t[i];
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
struct node {
long long x, y;
} a[M];
struct edg {
long long x, y;
int f;
} b[M];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &a[i].x, &a[i].y);
}
for (int i = 1; i <= n; i++) {
int y = i + 1;
if (y > n) y -= n;
b[i].x = a[i].x - a[y].x;
b[i].y = a[i].y - a[y].y;
}
int flag = 1;
if (n & 1) {
puts("NO");
return 0;
}
for (int i = 1; i <= n / 2; i++) {
int y = i + n / 2;
if (b[i].x == 0) {
if (abs(b[i].y) == abs(b[y].y))
continue;
else {
flag = 0;
break;
}
}
if (b[i].y == 0) {
if (abs(b[i].x) == abs(b[y].x))
continue;
else {
flag = 0;
break;
}
}
if (b[i].x * b[y].y == b[y].x * b[i].y) {
continue;
} else {
flag = 0;
break;
}
}
if (flag)
puts("YES");
else
puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t, m, arr[1001], i;
cin >> t;
while (t--) {
cin >> n >> m;
long long sum = 0;
for (i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
if (sum == m)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 10;
using namespace std;
const int inf = 0x3f3f3f3f;
int id[2 * maxn];
int a[2 * maxn];
int d[maxn];
int num[maxn];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n + m; i++) {
cin >> id[i];
}
int r = 1;
for (int i = 1; i <= m + n; i++) {
cin >> a[i];
if (a[i] == 1) {
d[r++] = id[i];
}
}
r--;
if (r == 1) {
printf("%d\n", n + m - 1);
break;
}
int p = 0;
for (int i = 1; i <= n + m; i++) {
if (a[i] == 1) {
p++;
}
if (a[i] == 0) {
if (id[i] < d[1]) {
num[1]++;
continue;
}
if (id[i] > d[r]) {
num[r]++;
continue;
}
if (d[p] + d[p + 1] >= 2 * id[i]) {
num[p]++;
} else
num[p + 1]++;
}
}
printf("%d", num[1]);
for (int i = 2; i <= r; i++) {
printf(" %d", num[i]);
}
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n = 0;
int k = 0;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<pair<int, int>> state;
map<int, int> d;
int start = 0;
int len = 0;
for (int i = 0; i < n; ++i) {
d[a[i]]++;
++len;
while (d.size() > k) {
d[a[start]]--;
if (d[a[start]] <= 0) d.erase(a[start]);
++start;
--len;
}
pair<int, int> curState(start, len);
state.push_back(curState);
}
int resId = 0;
int maxLen = state[resId].second;
for (int i = 0; i < n; ++i) {
if (maxLen < state[i].second) {
maxLen = state[i].second;
resId = i;
}
}
const int sRes = state[resId].first + 1;
const int eRes = sRes + state[resId].second - 1;
cout << sRes << " " << eRes << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int i;
cin >> N;
int A[N];
for(i=0;i<N;i++){
cin >> A[i];
}
sort(A,A+N,greater<int>());
int ret = 0;
for (i=0;i<N;i++)
ret +=A[i]*(i&1?-1:1);
cout << ret << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int md = 1e9 + 7;
const int Inf = 1e9;
const long long Inf64 = 1e18;
const int MaxN = 2e3 + 100;
const int LogN = 20;
const int MaxM = 2e5 + 10;
const double eps = 1e-3;
const int dx[8] = {0, 1, 0, -1, -1, 1, -2, -2};
const int dy[8] = {1, 0, -1, 0, -2, -2, 1, -1};
const int ddx[4] = {1, 1, -1, -1};
const int ddy[4] = {1, -1, 1, -1};
const double Pi = acos(-1);
using namespace std;
template <typename T>
istream &operator>>(istream &in, pair<T, T> &a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, pair<T, T> a) {
out << a.first << ' ' << a.second;
return out;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &Mt) {
for (T &a : Mt) in >> a;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> Mt) {
for (int i = 0; i < (int)Mt.size(); i++) {
out << Mt[i];
if (i != (int)Mt.size()) out << ' ';
}
out << '\n';
return out;
}
inline int Mod(int &a, int m = md) {
while (a >= m) a -= m;
return a;
}
inline int gcd(int a, int b) {
while (a) {
b %= a;
swap(a, b);
}
return b;
}
inline int gcdex(int a, int mod = md) {
int g = mod, r = a, x = 0, y = 1;
while (r != 0) {
int q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + mod : x;
}
inline int binpow(int a, int n, int m = md) {
int res = 1;
while (n) {
if (n & 1) {
res *= a;
res %= m;
}
a *= a;
a %= m;
n >>= 1;
}
return res % md;
}
vector<int> Ans;
vector<int> Gr[MaxN];
int Mt[MaxN];
vector<int> dfs(int v, int p = -1) {
vector<int> Res;
for (int to : Gr[v]) {
if (to == p) continue;
vector<int> t = dfs(to, v);
for (int k : t) {
Res.push_back(k);
}
}
if ((int)Res.size() < Mt[v]) {
cout << "NO";
exit(0);
}
Res.insert(Res.begin() + Mt[v], v);
return Res;
}
signed main() {
{
int N;
cin >> N;
int Root;
for (int i = 0; i < N; i++) {
int a, b;
cin >> a >> b;
Mt[i] = b;
if (a == 0) {
Root = i;
continue;
}
a--;
Gr[a].push_back(i);
Gr[i].push_back(a);
}
vector<int> Kt = dfs(Root);
Ans.assign(N, 0);
for (int i = 0; i < N; i++) {
Ans[Kt[i]] = i + 1;
}
cout << "YES" << '\n';
cout << Ans;
}
END:
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], b[200005];
multiset<int> s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = (1); i <= (n); i++) cin >> a[i];
for (int i = (1); i <= (n); i++) cin >> b[i], s.insert(b[i]);
for (int i = (1); i <= (n); i++) {
auto it = s.lower_bound(n - a[i]);
if (it == s.end()) it = s.begin();
cout << (a[i] + *it) % n << ' ';
s.erase(it);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int mat[100][100];
int dirx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int diry[] = {-1, 0, 1, -1, 1, -1, 0, 1};
long long n, a, s, m;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a, m = max(a, m), s += a;
cout << max(m, (s - 1) / (n - 1) + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int read() {
int f = 0;
char ch;
while (!isdigit(ch = getchar()))
;
do f = 10 * f + (ch ^ '0');
while (isdigit(ch = getchar()));
return f;
}
const int N_MAX = 100003;
int n, m, k, p, h[N_MAX], a[N_MAX];
long long c[N_MAX];
struct Data {
int id, day;
Data() {}
Data(int id, int day) : id(id), day(day) {}
friend bool operator<(const Data &lhs, const Data &rhs) {
return lhs.day > rhs.day;
}
};
bool check(long long now) {
std::priority_queue<Data> que;
for (int i = 1; i <= n; ++i) {
c[i] = now;
if (c[i] - 1ll * m * a[i] < h[i]) que.push(Data(i, c[i] / a[i]));
}
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= k && !que.empty(); ++j) {
Data x = que.top();
if (i > x.day) return 0;
que.pop();
c[x.id] += p;
if (c[x.id] - 1ll * m * a[x.id] < h[x.id])
que.push(Data(x.id, c[x.id] / a[x.id]));
}
return que.empty();
}
signed main() {
n = read(), m = read(), k = read(), p = read();
long long l = 0, r = 0;
for (int i = 1; i <= n; ++i) {
h[i] = read(), a[i] = read();
l = std::max(l, (long long)a[i]), r = std::max(r, 1ll * m * a[i] + h[i]);
}
while (l < r) {
long long mid = (l + r) >> 1;
check(mid) ? r = mid : l = mid + 1;
}
printf("%lld\n", l);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
int c[maxn];
int start[maxn];
int ans[maxn];
int main() {
int n, m, d;
scanf("%d%d%d", &n, &m, &d);
int en = n + 1;
for (int i = 1; i <= m; i++) {
scanf("%d", &c[i]);
}
for (int i = m; i >= 1; i--) {
en -= c[i];
start[i] = en;
}
int le = 1, posi = 0;
for (int i = 1; i <= m; i++) {
posi += d;
if (posi >= start[i]) {
if (posi < start[i] + c[i]) {
posi = start[i] + c[i] - 1;
}
for (int j = start[i]; j < start[i] + c[i]; j++) ans[j] = i;
} else {
for (int j = posi; j < posi + c[i]; j++) ans[j] = i;
posi += c[i];
posi -= 1;
}
}
if (posi + d < n + 1)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000003];
int main(void) {
long long num, jump, m, l;
scanf("%lld%lld%lld%lld", &num, &jump, &m, &l);
for (long long i = 0; i < num; i++) {
a[i] = ((i + 1) - 1) * m;
}
long long next = 0, i = 0;
while (1) {
long long vv = a[i] + l - next;
long long d = vv / jump;
next += (jump * (d + 1));
while (i < num && a[i] <= next) ++i;
--i;
if (a[i] + l >= next) {
if (i + 1 == num) {
long long vv = a[i] + l - next;
long long d = vv / jump;
next += (jump * (d + 1));
break;
} else
continue;
} else
break;
}
printf("%lld\n", next);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solutionD();
int main() {
ios_base::sync_with_stdio(false);
solutionD();
return EXIT_SUCCESS;
}
long long n, m, p[4096], p2[4096], u[4096];
long long c[4096], sz[4096];
long long count() {
for (long long i = 0; i < n; ++i) u[i] = 0;
long long res2 = 0;
for (long long i = 0; i < n; ++i) {
if (u[i]) continue;
long long len = 0;
long long v = i;
while (!u[v]) {
++len;
u[v] = 1;
v = p[v] - 1;
}
res2 += len - 1;
}
return res2;
}
void build() {
for (long long i = 0; i < n; ++i) u[i] = 0;
long long k = 0;
for (long long i = 0; i < n; ++i) {
if (u[i]) continue;
long long v = i;
while (!u[v]) {
u[v] = 1;
c[v] = k;
v = p[v] - 1;
}
++k;
}
}
vector<pair<long long, long long>> solve_naive() {
long long cnt = count();
vector<pair<long long, long long>> ans;
if (m > cnt) {
for (long long i = 0; i < n && cnt < m; ++i) {
build();
long long index = -1;
for (long long j = i + 1; j < n; ++j)
if (c[i] != c[j]) {
index = j;
break;
}
if (index != -1) {
swap(p[i], p[index]);
ans.emplace_back(i, index);
cnt = count();
--i;
}
}
} else if (m < cnt) {
for (long long i = 0; i < n && cnt > m; ++i) {
if (p[i] == i + 1) continue;
build();
long long index = -1;
for (long long j = i + 1; j < n; ++j) {
if (c[i] != c[j]) continue;
index = j;
break;
}
if (index != -1) {
swap(p[i], p[index]);
ans.emplace_back(i, index);
cnt = count();
--i;
}
}
}
return ans;
}
void solve() {
vector<pair<long long, long long>> ans = solve_naive();
cout << ans.size() << endl;
for (auto it : ans) cout << it.first + 1 << " " << it.second + 1 << " ";
cout << endl;
}
void solutionD() {
for (; cin >> n;) {
for (long long i = 0; i < n; ++i) cin >> p[i];
cin >> m;
solve();
cerr << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
fast();
int t = 1;
while (t--) {
int m, n, q;
cin >> m >> n;
vector<vector<char>> mat(m + 1, vector<char>(n + 1, '$'));
vector<vector<int>> row(m + 1, vector<int>(n + 1)),
dp(m + 1, vector<int>(n + 1)), col(m + 1, vector<int>(n + 1));
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) cin >> mat[i][j];
}
for (int j = 1; j <= n; j++) {
vector<int> c(m + 1);
for (int i = 1; i <= m; i++) {
if (mat[i][j] == '.' && mat[i - 1][j] == '.')
c[i] = c[i - 1] + 1;
else
c[i] = c[i - 1];
col[i][j] = col[i][j - 1] + c[i];
}
}
for (int i = 1; i <= m; i++) {
vector<int> r(n + 1);
for (int j = 1; j <= n; j++) {
if (mat[i][j] == '.' && mat[i][j - 1] == '.')
r[j] = r[j - 1] + 1;
else
r[j] = r[j - 1];
row[i][j] = row[i - 1][j] + r[j];
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) dp[i][j] = row[i][j] + col[i][j];
}
cin >> q;
for (int i = 0; i < q; i++) {
int x, y, x1, y1;
cin >> x >> y >> x1 >> y1;
int rem1 = row[x][y1] - row[x - 1][y1] - row[x][y] + row[x - 1][y];
int rem2 = col[x1][y] - col[x1][y - 1] - col[x][y] + col[x][y - 1];
cout << dp[x1][y1] - dp[x1][y] - dp[x][y1] + dp[x][y] + rem1 + rem2
<< endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = 610;
vector<int> ed[maxn];
int go(vector<int> a) {
if ((int)a.size() <= 1) {
return 0;
}
cout << "? " << a.size() << endl;
for (int i = 0; i < (int)a.size(); i++) {
cout << a[i] << ' ';
}
cout << endl;
int ans;
cin >> ans;
return ans;
}
bool used[maxn];
int n;
int col[maxn];
void dfs(int v, int c) {
used[v] = true;
col[v] = c;
while (true) {
vector<int> a;
for (int i = 1; i <= n; i++) {
if (!used[i]) {
a.push_back(i);
}
}
a.push_back(v);
int cur = go(a);
a.pop_back();
cur -= go(a);
if (cur == 0) {
break;
}
while (a.size() != 1) {
vector<int> b;
while (a.size() > b.size()) {
b.push_back(a.back());
a.pop_back();
}
b.push_back(v);
int now = go(b);
b.pop_back();
now -= go(b);
if (now == 0) {
continue;
}
a = b;
}
ed[v].push_back(a[0]);
ed[a[0]].push_back(v);
dfs(a[0], c ^ 1);
}
}
vector<int> w;
bool write(int v, int p, int u) {
if (v == u) {
w.push_back(v);
return true;
}
for (int i = 0; i < (int)ed[v].size(); i++) {
int to = ed[v][i];
if (to != p && write(to, v, u)) {
w.push_back(v);
return true;
}
}
return false;
}
void check(int c) {
vector<int> a;
for (int i = 1; i <= n; i++) {
if (col[i] == c) {
a.push_back(i);
}
}
int cur = go(a);
if (cur == 0) {
return;
}
while (true) {
int v = a.back();
a.pop_back();
int ncur = go(a);
if (ncur == cur) {
cur = ncur;
continue;
}
vector<int> b;
b.push_back(v);
for (int i = 0; i < (int)a.size(); i++) {
b.push_back(a[i]);
int u = a[i];
if (go(b) != 0) {
if (!write(u, -1, v)) {
throw 1;
}
cout << "N " << w.size() << endl;
for (int j = 0; j < (int)w.size(); j++) {
cout << w[j] << ' ';
}
cout << endl;
exit(0);
}
}
}
}
int main() {
cin >> n;
dfs(1, 0);
for (int i = 1; i <= n; i++) {
if (!used[i]) {
throw 1;
}
}
check(0);
check(1);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (col[i] == 0) {
ans.push_back(i);
}
}
cout << "Y " << ans.size() << endl;
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i] << ' ';
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, q;
int fa[N];
int nxt[N];
int find(int x) { return x == fa[x] ? x : (fa[x] = find(fa[x])); }
void mrg(int x, int y) {
x = find(x);
y = find(y);
if (x != y) {
fa[x] = y;
}
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
fa[i] = i;
nxt[i] = i + 1;
}
while (q--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
mrg(x, y);
} else if (t == 2) {
int fy = find(y);
for (int i = x; i <= y;) {
fa[find(i)] = fy;
int tmp = i;
i = nxt[i];
nxt[tmp] = nxt[y];
}
} else {
puts(find(x) == find(y) ? "YES" : "NO");
}
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 1005
#define HUGE_NUM 9999999999999999
struct Edge{
Edge(int arg_to,ll arg_cost,bool arg_is_magical){
to = arg_to;
cost = arg_cost;
is_magical = arg_is_magical;
}
int to;
ll cost;
bool is_magical;
};
struct State{
State(){
node_id = 0;
num_passed_magical = 0;
sum_cost = 0;
}
State(int arg_node_id,int arg_num_passed_magical,ll arg_sum_cost){
node_id = arg_node_id;
num_passed_magical = arg_num_passed_magical;
sum_cost = arg_sum_cost;
}
bool operator<(const struct State &arg) const{
return sum_cost > arg.sum_cost;
}
int node_id,num_passed_magical;
ll sum_cost;
};
int N,M,S_1,S_2,T;
int num_magical;
vector<Edge> G[NUM];
ll min_dist[105][NUM];
ll getNUM(char buf[20]){
ll ret = 0;
for(int i = 0; buf[i] != '\0'; i++){
ret = 10*ret+(buf[i]-'0');
}
return ret;
}
double calc_len(ll slope_1,ll num_1,ll slope_2,ll num_2){
return (double)(num_2-num_1)/(double)(slope_1-slope_2);
}
ll get_min_cost(int node,ll tmp_len){
ll ret = HUGE_NUM;
for(ll i = 0; i <= num_magical; i++){
ret = min(ret,min_dist[i][node]+i*tmp_len);
}
return ret;
}
void dijkstra(int start){
for(int i = 0; i <= num_magical; i++){
for(int k = 0; k < N; k++){
min_dist[i][k] = HUGE_NUM;
}
}
priority_queue<State> Q;
min_dist[0][start] = 0;
Q.push(State(start,0,0));
int next_node,next_num_pass;
ll next_cost;
State state;
while(!Q.empty()){
state = Q.top();
Q.pop();
if(state.sum_cost > min_dist[state.num_passed_magical][state.node_id]){
continue;
}
for(int i = 0; i < G[state.node_id].size(); i++){
next_node = G[state.node_id][i].to;
next_cost = state.sum_cost+G[state.node_id][i].cost;
next_num_pass = state.num_passed_magical;
if(G[state.node_id][i].is_magical){
next_num_pass++;
}
if(min_dist[next_num_pass][next_node] > next_cost){
min_dist[next_num_pass][next_node] = next_cost;
Q.push(State(next_node,next_num_pass,next_cost));
}
}
}
}
void func(){
for(int i = 0; i < N; i++){
G[i].clear();
}
S_1--;
S_2--;
T--;
char buf[20];
int from,to;
ll cost;
num_magical = 0;
for(int loop = 0; loop < M; loop++){
scanf("%d %d %s",&from,&to,buf);
from--;
to--;
if(buf[0] != 'x'){
cost = getNUM(buf);
G[from].push_back(Edge(to,cost,false));
G[to].push_back(Edge(from,cost,false));
}else{
num_magical++;
cost = 0;
G[from].push_back(Edge(to,cost,true));
G[to].push_back(Edge(from,cost,true));
}
}
dijkstra(T);
vector<ll> V; //長さの候補
double len[3];
for(ll i = 0; i <= num_magical; i++){
for(ll k = 0; k <= num_magical; k++){
if(k == i)continue;
for(int a = 0; a < 3; a++)len[a] = 0;
if(min_dist[i][S_1] != HUGE_NUM && min_dist[k][S_1] != HUGE_NUM)len[0] = calc_len(i,min_dist[i][S_1],k,min_dist[k][S_1]);
if(min_dist[i][S_1] != HUGE_NUM && min_dist[k][S_2] != HUGE_NUM)len[1] = calc_len(i,min_dist[i][S_1],k,min_dist[k][S_2]);
if(min_dist[i][S_2] != HUGE_NUM && min_dist[k][S_2] != HUGE_NUM)len[2] = calc_len(i,min_dist[i][S_2],k,min_dist[k][S_2]);
for(ll diff = -1; diff <= 1; diff++){
for(int a = 0; a < 3; a++){
V.push_back((ll)len[a]+diff);
}
}
}
}
sort(V.begin(),V.end());
V.erase(unique(V.begin(),V.end()),V.end());
ll ans = HUGE_NUM;
if(min_dist[0][S_1] != HUGE_NUM && min_dist[0][S_2] != HUGE_NUM){
ans = abs(min_dist[0][S_1]-min_dist[0][S_2]);
}
ll tmp_len;
ll A_cost,B_cost;
for(int i = 0; i < V.size(); i++){
tmp_len = V[i];
if(tmp_len < 0)continue;
A_cost = get_min_cost(S_1,tmp_len);
B_cost = get_min_cost(S_2,tmp_len);
ans = min(ans,abs(A_cost-B_cost));
}
printf("%lld\n",ans);
}
int main(){
while(true){
scanf("%d %d %d %d %d",&N,&M,&S_1,&S_2,&T);
if(N == 0 && M == 0 && S_1 == 0 && S_2 == 0 && T == 0)break;
func();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
char c;
cin >> c;
string str;
cin >> str;
long long ctr = 0;
long long k = 0;
for (long long i = 0; i < n; i++) {
if (str[i] != c) {
ctr++;
k = i;
}
}
if (ctr == 0) {
cout << 0;
} else if (ctr == 1) {
if (k == n - 1) {
cout << 1 << "\n";
cout << k;
} else {
cout << 1 << "\n";
cout << k + 2;
}
} else {
long long flag = 0;
for (long long i = n - 1; i >= n / 2; i--) {
if (str[i] == c) {
flag = i;
break;
}
}
if (flag) {
cout << 1 << "\n";
cout << flag + 1;
} else {
cout << 2 << "\n";
cout << n << " " << n - 1;
}
}
cout << "\n";
}
return 0;
}
| 3 |
#include<iostream>
using namespace std;
typedef long long ll;
int main(){
ll a[105][105]={{}};
ll b[105][105]={{}};
int n,m,l;
int i,j,k;
cin >> n >> m >> l;
for(i=0;i<n;i++){
for(j=0;j<m;j++){
cin >> a[i][j];
}
}
for(i=0;i<m;i++){
for(j=0;j<l;j++){
cin >> b[i][j];
}
}
for(i=0;i<n;i++){
for(j=0;j<l;j++){
ll o=0;
for(k=0;k<m;k++){
o+=a[i][k]*b[k][j];
}
if(j==0) cout << o;
else cout << " " << o;
}
cout << endl;
}
return 0;
}
| 0 |
#include<cstdio>
#include<algorithm>
#include<vector>
#include<deque>
#include<string>
#include<iostream>
#include<tuple>
#include<utility>
#include<set>
#include<queue>
using namespace std;
typedef long long int llint;
const llint big=((llint)1<<(llint)30);
#define mt make_tuple
#define mp make_pair
#define fi first
#define se second
#define pub push_back
#define res resize
//JOI 2017 semiexp O(NlogN)
//3:25~
//Tmin
int main(void){
llint N,M,K,A,B,C,T,ans=0,i,j,it,bef,stenum,minit,nokori;
priority_queue<tuple<llint,llint,llint>> kyu;//next_ste_num,minite,nokori_ste
cin>>N>>M>>K>>C>>A>>B>>T;
cin>>bef;
bef--;
for(i=1;i<M;i++){
cin>>it;
it--;
stenum=min((T-bef*A+C)/C,it-bef);
ans+=max((llint)0,stenum);
minit=bef*A;
nokori=it-bef;
kyu.push(mt(min((T-minit-stenum*B+C)/C,nokori-stenum),minit+stenum*B,nokori-stenum));
//if(min((T-bef*A+C)/C,it-bef)<=0){printf("hsdlakj\n");}
bef=it;
}
it=N;
stenum=min((T-bef*A+C)/C,it-bef);
ans+=max((llint)0,stenum);
minit=bef*A;
nokori=it-bef;
kyu.push(mt(min((T-minit-stenum*B+C)/C,nokori-stenum),minit+stenum*B,nokori-stenum));
//if(min((T-bef*A+C)/C,it-bef)<=0){printf("asaj\n");}
K-=M;
for(i=0;i<K;i++){
stenum=get<0>(kyu.top());
minit=get<1>(kyu.top());
nokori=get<2>(kyu.top());
kyu.pop();
if(stenum<=0){break;}
ans+=stenum;
//if(ans==0){printf("de%d\n",i);}
kyu.push(mt(min((T-minit-stenum*B+C)/C,nokori-stenum),minit+stenum*B,nokori-stenum));
//if(min((T-minit-stenum*B+C)/C,nokori-stenum)<=0){printf("ko%d\n",i);}
}
cout<<ans-1<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, ans1, ans2;
double amax = 1.0e9, amin = 1.0, x, y, i;
int main() {
cin >> n;
for (i = x = 1.0; x < n + 0.1; x++) {
cin >> y;
for (; i <= y; i++) {
amin = max(amin, i / x);
}
amax = min(amax, i / x);
}
ans1 = (n + 1) * (amax - 1e-9);
ans2 = (n + 1) * (amin + 1e-9);
if (ans1 == ans2)
cout << "unique" << endl << ans1 << endl;
else
cout << "not unique" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#include<set>
using namespace std;
int main() {
set<int> S;
int N;
cin>>N;
for(int i = 0; i<N; i+=1) {
int d;
cin>>d;
S.insert(d);
}
cout<<S.size()<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char a[1001][1001];
long long int row[1001], col[1001];
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
long long int i, j, n, m, ans = 0;
cin >> n >> m;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == '*') {
row[i]++;
col[j]++;
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (a[i][j] == '*') ans += (row[i] - 1) * (col[j] - 1);
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> k;
int m = n * k;
if (m > (n * (n - 1)) / 2) {
cout << -1;
return 0;
}
cout << m << '\n';
for (int i = 0; i < n; i++)
for (int j = 0; j < k; j++)
cout << i + 1 << ' ' << (i + j + 1) % n + 1 << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, v[1001], ok = 0;
char p[1001], o[1001], l, qs, ss;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> p;
if (p[0] == 'T') ok += 4;
if (p[0] == 'C') ok += 6;
if (p[0] == 'O') ok += 8;
if (p[0] == 'D') ok += 12;
if (p[0] == 'I') ok += 20;
}
cout << ok;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (long long)(1e5) + 5, mod = (long long)(1e9) + 7;
int n, m, x, y, ans;
vector<vector<int> > vec;
vector<bool> arr, vis;
void dfs(int node, int cnt) {
int c = 0;
vis[node] = 1;
if (cnt > m) return;
for (auto &i : vec[node])
if (!vis[i]) c++;
if (!c) {
ans++;
}
for (auto &i : vec[node]) {
if (!vis[i]) {
if (cnt + arr[i] == cnt)
dfs(i, 0);
else
dfs(i, cnt + arr[i]);
}
}
}
int main() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> m;
vec.resize(n), vis.resize(n), arr.resize(n);
for (int i = 0; i < n; i++) cin >> x, arr[i] = x;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
vec[x - 1].push_back(y - 1);
vec[y - 1].push_back(x - 1);
}
dfs(0, arr[0]);
cout << ans << endl;
return 0;
}
| 3 |
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long int ll;
static const int MAX_N = 1000;
static const int MAX_M = 1000;
int N, M;
ll D[MAX_N + 1], C[MAX_M + 1];
ll memo[MAX_N + 1][MAX_M + 1];
int main(){
cin >> N >> M;
for(int i = 1; i <= N; i++) cin >> D[i];
for(int i = 1; i <= M; i++) cin >> C[i];
fill(memo[0], memo[N + 1], 0);
for(int i = 1; i <= N; i++) memo[i][i] = memo[i - 1][i - 1] + D[i] * C[i];
for(int i = 1; i <= N; i++){
for(int j = i + 1; j <= M; j++){
memo[i][j] = min(memo[i][j - 1], memo[i - 1][j - 1] + D[i] * C[j]);
}
}
cout << memo[N][M] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int q;
cin >> q;
for (int qc = 0; qc < (q); ++qc) {
int n;
string s, t;
cin >> n >> s >> t;
string s_s = s;
string t_s = t;
sort((s_s).begin(), (s_s).end());
sort((t_s).begin(), (t_s).end());
if (s_s != t_s) {
cout << -1 << '\n';
continue;
}
int j = 0;
for (int i = 0; i + j < n; ++i) {
int l = 0;
for (int k = 0; max(k, i + l) < n; ++k) {
if (s[k] == t[i + l]) {
l++;
}
}
j = max(j, l);
}
cout << n - j << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 6e5 + 15, MOD = 1e9 + 7;
long long n;
long long par[MAX_N];
long long Arr[MAX_N];
vector<long long> child[MAX_N];
long long L[MAX_N], R[MAX_N], deep[MAX_N];
pair<pair<long long, long long>, long long> seg[MAX_N << 2];
long long dfs(long long v = 0, long long val = 0) {
Arr[val] = v;
deep[v] = 1 + deep[par[v]];
L[v] = val, R[v] = val + 1;
for (long long i = 0; i < child[v].size(); i++) R[v] = dfs(child[v][i], R[v]);
return R[v];
}
void upd(long long l, long long r, long long x, long long k, long long h,
long long s = 0, long long e = n, long long id = 1) {
if (l <= s && e <= r) {
x = (((x - k * (seg[id].second - h)) % MOD) + MOD) % MOD;
seg[id].first.first = (x + seg[id].first.first) % MOD;
seg[id].first.second = (seg[id].first.second + k) % MOD;
return;
}
if (r <= s || e <= l) return;
long long mid = e + s >> 1;
upd(l, r, x, k, h, s, mid, id << 1);
upd(l, r, x, k, h, mid, e, id << 1 | 1);
}
long long get(long long v, long long s = 0, long long e = n, long long id = 1) {
if (e - s == 1)
return (((seg[id].first.first -
seg[id].first.second * abs(seg[id].second - deep[Arr[v]]) % MOD) %
MOD) +
MOD) %
MOD;
long long mid = e + s >> 1;
if (v < mid)
return ((((seg[id].first.first - seg[id].first.second *
abs(seg[id].second - deep[Arr[v]]) %
MOD) %
MOD +
get(v, s, mid, id << 1)) %
MOD) +
MOD) %
MOD;
else
return ((((seg[id].first.first - seg[id].first.second *
abs(seg[id].second - deep[Arr[v]]) %
MOD) %
MOD +
get(v, mid, e, id << 1 | 1)) %
MOD) +
MOD) %
MOD;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i < n; i++) {
scanf("%lld", &par[i]);
par[i]--;
child[par[i]].push_back(i);
}
dfs();
long long q;
scanf("%lld", &q);
while (q--) {
long long type, v;
scanf("%lld %lld", &type, &v);
v--;
if (type == 1) {
long long x, k;
scanf("%lld %lld", &x, &k);
upd(L[v], R[v], x, k, deep[v]);
} else
printf("%lld\n", get(L[v]));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define for_(i,a,b) for(int i=(a);i<(b);++i)
int main() {
string S;
cin >> S;
int n = S.size();
if (n == 2 && S[0] == S[1]) {
puts("1 2");
exit(0);
}
for_(i,0,n-2) {
if (S[i] == S[i+1] || S[i] == S[i+2]) {
cout << i+1 << " " << i + 3 << endl;
exit(0);
}
}
puts("-1 -1");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string d[] = {"Danil", "Olya", "Slava", "Ann", "Nikita"};
int ls, ld, i, l, j, k, m, cnt = 0;
string s;
cin >> s;
for (j = 0; j < 5; j++) {
ld = d[j].size();
for (i = 0; i < s.size(); i = m) {
l = 0;
m = i;
for (k = 0; k < ld; k++) {
if (s[m] == d[j][k]) {
l++;
m++;
}
}
if (m == i) m++;
if (l == ld) cnt++;
}
}
if (cnt == 1)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100000 + 10;
const int inf = 0x3f3f3f3f;
int n;
int above[max_n];
long long below[max_n];
int cnt, head[max_n];
bool in[max_n];
struct ini {
int to, next;
long long len;
ini() {}
ini(int to, long long len, int next) : to(to), len(len), next(next) {}
} edge[max_n << 2];
inline void addedge(int from, int to, long long len) {
edge[cnt] = ini(to, len, head[from]);
head[from] = cnt++;
}
void spfa() {
queue<int> que;
que.push(0);
in[0] = true;
below[0] = 0;
while (que.size()) {
int u = que.front();
que.pop();
in[u] = false;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (below[v] < below[u] + edge[i].len) {
below[v] = below[u] + edge[i].len;
if (!in[v]) {
in[v] = true;
que.push(v);
}
}
}
}
}
int main() {
memset(head, -1, sizeof(head));
memset(in, false, sizeof(in));
memset(below, -1, sizeof(below));
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &above[i]);
addedge(0, i, 0);
}
for (int i = 1; i <= n; ++i) {
addedge(i - 1, i, above[i - 1] - above[i]);
addedge(i, i - 1, above[i] - above[i - 1] - 1);
}
spfa();
long long ans = 0;
for (int i = 1; i <= n; ++i) ans += below[i];
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long cnt = 1;
long long x[n][n];
for (int i = 0; i < n; i++) {
long long cnt1 = 0;
if (i & 1) {
for (int j = cnt, k = 0;; k++, j++) {
x[k][i] = j;
cnt1++;
if (cnt1 == n) {
break;
}
}
} else {
for (int j = cnt + (n - 1), k = 0;; k++, j--) {
x[k][i] = j;
cnt1++;
if (cnt1 == n) {
break;
}
}
}
cnt += n;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << x[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long LLINF = 1e18 + 7;
int pref[200009][26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
;
int n;
string s, t;
int q;
cin >> s >> q;
n = s.size();
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
pref[i][j] = pref[i - 1][j];
}
pref[i][s[i - 1] - 'a']++;
}
while (q--) {
int l, r;
cin >> l >> r;
if (r == l) {
cout << "Yes\n";
continue;
}
bool ans = true;
int cnt = 0;
for (int i = 0; i < 26; i++) {
if (pref[r][i] - pref[l - 1][i] > 0) {
cnt++;
}
}
if (s[r - 1] != s[l - 1] || cnt > 2) {
cout << "Yes\n";
continue;
}
if (cnt == 1) {
cout << "No\n";
continue;
}
cout << "No\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ans = INT_MAX;
cin >> n;
unordered_map<long long, long long> m;
long long temp, index;
for (long long i = 1; i <= n; i++) {
cin >> temp;
m[temp]++;
if (temp < ans) {
ans = temp;
index = i;
}
}
if (m[ans] > 1) {
cout << "Still Rozdil";
} else {
cout << index;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = LLONG_MAX;
int M = 1e9 + 7;
bool vowel(char ch) {
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u' ||
ch == 'y')
return 1;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
int n;
cin >> n;
int a[n + 1], mini = 1e9, tot = 0;
for (long long int i = 1; i <= n; i++) cin >> a[i], tot += a[i];
for (long long int i = 1; i <= n; i++) {
int cur = 0;
for (long long int j = i; j <= n; j++) {
cur += a[j];
mini = min(mini, abs(tot - 2 * cur));
if (cur >= tot - cur) break;
}
}
cout << mini;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[31][31][51];
int DP(int n, int m, int k) {
if (k == 0) return 0;
if (k > n * m) return 1000000000;
if (k == n * m) return 0;
if (dp[n][m][k] != -1) return dp[n][m][k];
dp[n][m][k] = 1000000000;
for (int i = 1; i < m; i++) {
for (int j = 0; j <= k; j++) {
dp[n][m][k] = min(dp[n][m][k], DP(n, i, j) + DP(n, m - i, k - j) + n * n);
}
}
for (int i = 1; i < n; i++) {
for (int j = 0; j <= k; j++) {
dp[n][m][k] = min(dp[n][m][k], DP(i, m, j) + DP(n - i, m, k - j) + m * m);
}
}
return dp[n][m][k];
}
int main() {
int t;
memset(dp, -1, sizeof dp);
scanf("%d", &t);
while (t--) {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
printf("%d\n", DP(n, m, k));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T, S, q, x, ans;
while (scanf("%d%d%d", &T, &S, &q) != EOF) {
ans = 1;
x = q * S;
while (x < T) {
x = q * x;
ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 7;
int i, j, l, t, n, m;
long long ans, k;
char s[MAXN];
int main() {
cin >> n >> m;
cin >> s + 1;
ans = n * (m - 1);
for (int i = 2; i <= n; i++)
if (s[i] != s[i - 1]) ans += n * (m - 1);
k = 1;
for (int i = 2; i <= n; i++) {
if (k == 1) {
if (s[i] != s[i - 1])
k++;
else
continue;
} else {
if (s[i] == s[i - 2])
k++;
else {
ans -= (k - 1) * k / 2;
k = 1;
if (s[i] != s[i - 1]) k = 2;
}
}
}
ans -= (k - 1) * k / 2;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > v[5] = {
{pair<int, int>(0, 0), pair<int, int>(1, 0), pair<int, int>(2, 0),
pair<int, int>(1, -1), pair<int, int>(1, -2)},
{pair<int, int>(0, 0), pair<int, int>(1, 0), pair<int, int>(2, 0),
pair<int, int>(1, 1), pair<int, int>(1, 2)},
{pair<int, int>(0, 0), pair<int, int>(0, 1), pair<int, int>(0, 2),
pair<int, int>(1, 1), pair<int, int>(2, 1)},
{pair<int, int>(0, 0), pair<int, int>(1, 0), pair<int, int>(2, 0),
pair<int, int>(2, -1), pair<int, int>(2, 1)}};
int nans[15][15] = {
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 1, 1, 2, 2, 3, 3, 4},
{0, 0, 0, 1, 2, 2, 3, 4, 4, 5}, {0, 0, 0, 2, 2, 4, 4, 5, 6, 7},
{0, 0, 0, 2, 3, 4, 5, 6, 7, 8}, {0, 0, 0, 3, 4, 5, 6, 8, 9, 10},
{0, 0, 0, 3, 4, 6, 7, 9, 10, 12}, {0, 0, 0, 4, 5, 7, 8, 10, 12, 13}};
void init() { scanf("%d%d", &n, &m); }
char brd[15][15];
char ans[15][15];
int am;
void copyy() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ans[i][j] = brd[i][j];
}
bool ok(int i, int j, vector<pair<int, int> > &mv) {
for (pair<int, int> qq : mv) {
int ti = i + qq.first, tj = j + qq.second;
if (ti < 0 || ti >= n || tj < 0 || tj >= m) return false;
if (brd[ti][tj] != '.') return false;
}
return true;
}
bool fll(int i, int j, vector<pair<int, int> > &mv, char now) {
for (pair<int, int> qq : mv) {
int ti = i + qq.first, tj = j + qq.second;
brd[ti][tj] = now;
}
}
bool clr(int i, int j, vector<pair<int, int> > &mv) {
for (pair<int, int> qq : mv) {
int ti = i + qq.first, tj = j + qq.second;
brd[ti][tj] = '.';
}
}
void dfs(int i, int j, char now) {
if (am >= nans[n][m]) return;
if (i == n) {
if (now - 'A' > am) {
am = now - 'A';
copyy();
}
return;
}
int ni = i, nj = j + 1;
if (nj == m) nj = 0, ni++;
if (brd[i][j] != '.') {
dfs(ni, nj, now);
return;
}
for (int k = 0; k < 4; k++) {
if (ok(i, j, v[k])) {
fll(i, j, v[k], now);
dfs(ni, nj, now + 1);
clr(i, j, v[k]);
}
}
dfs(ni, nj, now);
}
void process() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) brd[i][j] = ans[i][j] = '.';
dfs(0, 0, 'A');
printf("%d\n", am);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", ans[i][j]);
puts("");
}
}
int main() {
init();
process();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chmax(T& a, const T& b) {
return a < b ? (a = b, true) : false;
}
template <typename T>
bool chmin(T& a, const T& b) {
return b < a ? (a = b, true) : false;
}
int N, Q;
vector<int> A[200001];
int main() {
scanf("%d", &N);
for (int i = (0); i < (N); i++) {
int X, Y;
scanf("%d%d", &X, &Y);
A[X].push_back(Y);
}
set<pair<int, int> > st;
for (int i = 1; i <= N; i++)
if (A[i].empty() == false) {
st.insert({A[i].back(), i});
}
scanf("%d", &Q);
for (int i = (0); i < (Q); i++) {
int K;
scanf("%d", &K);
vector<int> query(K);
for (int i = (0); i < (K); i++) {
scanf("%d", &query[i]);
if (A[query[i]].empty() == false) {
st.erase({A[query[i]].back(), query[i]});
}
}
if (st.empty()) {
printf("0 0\n");
} else if (st.size() == 1) {
int x = st.rbegin()->second;
printf("%d %d\n", x, A[x].front());
} else {
auto it = st.rbegin();
it++;
int x = st.rbegin()->second;
printf("%d %d\n", x,
*upper_bound((A[x]).begin(), (A[x]).end(), it->first));
}
for (int i = (0); i < (K); i++)
if (A[query[i]].empty() == false) {
st.insert({A[query[i]].back(), query[i]});
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (m > n)
cout << -1;
else {
int ans = n / 2;
int rem = n % 2;
if ((ans + rem) % m == 0)
cout << ans + rem;
else
cout << (ans + rem) + (m - ((ans + rem) % m));
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int dx[4]={0,1,0,-1};
const int dy[4]={1,0,-1,0};
int n,m,k,mn,dist[805][805];
char s[805][805];
queue<pair<int,int> >q;
int dis(int x,int y){return (min(min(x,y),min(n-1-x,m-1-y))+k-1)/k;}
int main()
{
scanf("%d%d%d",&n,&m,&k);
memset(dist,-1,sizeof(dist));
for(int i=0;i<n;i++)
{
scanf("%s",s[i]);
for(int j=0;j<m;j++)
{
if(s[i][j]=='S')
{
q.push(make_pair(i,j));
dist[i][j]=0;
mn=dis(i,j)+1;
}
}
}
while(!q.empty())
{
int x=q.front().first,y=q.front().second;
q.pop();
if(dist[x][y]==k)break;
for(int i=0;i<4;i++)
{
int xx=x+dx[i],yy=y+dy[i];
if(xx>=0&&xx<n&&yy>=0&&yy<m&&s[xx][yy]=='.'&&dist[xx][yy]==-1)
{
dist[xx][yy]=dist[x][y]+1;
q.push(make_pair(xx,yy));
mn=min(mn,dis(xx,yy)+1);
}
}
}
printf("%d\n",mn);
return 0;
}
| 0 |
#include <iostream>
#include <cmath>
using namespace std;
int main() {
int n,t;
int num[100005] = {};
cin >> n >> t;
for(int i = 0;i < n;i++){
int a,b;
cin >> a >> b;
num[a]++;
num[b]--;
}
int ma = num[0];
for(int i = 1;i <= t;i++){
num[i] += num[i - 1];
ma = max(num[i],ma);
}
cout << ma << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, T;
int sum[1000005];
char s[500005];
bool check(int x) {
int i, j, t;
for (i = n; i < n + x; i++) {
j = i - x;
t = sum[i] - sum[j] + x + min(n - j - 1, i - n) * 2 * a +
max(n - j - 1, i - n) * a;
if (t <= T) return true;
}
return false;
}
int main() {
int i, l, r, m;
int ans;
scanf("%d%d%d%d %s", &n, &a, &b, &T, s);
for (i = 0; i < n * 2; i++) {
sum[i] = sum[i - 1];
if (i >= n)
sum[i] += b * (s[i - n] == 'w');
else
sum[i] += b * (s[i] == 'w');
}
ans = 0;
l = 0;
r = n;
while (l <= r) {
m = (l + r) / 2;
if (check(m)) {
ans = m;
l = m + 1;
} else
r = m - 1;
}
printf("%d", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
unsigned long long ap(unsigned long long a, unsigned long long b) {
assert(a <= b);
a %= MOD;
b %= MOD;
return (b + a) % MOD * (b + (MOD - a) + 1) % MOD * 500000004 % MOD;
}
int main() {
unsigned long long n, m;
cin >> n >> m;
unsigned long long sagot = 0, sagot2 = (n % MOD) * (m % MOD) % MOD;
unsigned long long i;
unsigned long long first;
for (i = 1; i * i <= n && i <= m; i++) {
first = n / (i + 1) + 1;
unsigned long long last = min(m, n / i);
if (first <= last) {
sagot = (sagot + (i * ap(first, last) % MOD)) % MOD;
}
}
for (unsigned long long i = 1; i < first && i <= m; i++) {
unsigned long long v = n / i * i;
sagot = (sagot + (v % MOD)) % MOD;
}
cout << (sagot2 + MOD - sagot) % MOD << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r, k;
cin >> l >> r >> k;
int ok = 0;
long long x = 1ll;
while (x <= r) {
if (x >= l) {
ok++;
cout << x << ' ';
}
if (r / k < x)
break;
else
x = x * k;
}
if (ok == 0) cout << "-1";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > a;
vector<int> result;
int main() {
int n, i, x, y, sign = -100001, res = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
if (x > y) swap(x, y);
a.push_back(pair<int, int>(y, x));
}
sort(a.begin(), a.end());
for (i = 0; i < n; i++) {
if (sign >= a[i].second && a[i].first >= sign) {
continue;
} else {
sign = a[i].first;
res++;
result.push_back(a[i].first);
}
}
printf("%d\n", res);
printf("%d", result[0]);
for (i = 1; i < res; i++) {
printf(" %d", result[i]);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int query(vector<int> a, vector<int> b, int v) {
if (a.empty() || b.empty()) return 0;
printf("%d\n", a.size());
for (int u : a) printf("%d ", u);
printf("\n%d\n", b.size());
for (int u : b) printf("%d ", u);
printf("\n%d\n", v);
fflush(stdout);
int ans;
gn(ans);
return ans;
}
vector<pair<int, int> > edge;
vector<pair<int, int> > vec;
int n, vst[510];
int sz[510];
void dfs(int p) {
vst[p] = sz[vec[p].second] = 1;
if (vec[p].second == 1) {
for (int i = p + 1; i < n; i++)
if (!vst[i]) {
edge.push_back(pair<int, int>(1, vec[i].second));
dfs(i);
}
} else {
while (sz[vec[p].second] < vec[p].first) {
int st = p, ed = n;
while (ed - st > 1) {
int mid = st + ed >> 1;
vector<int> a;
a.push_back(1);
vector<int> b;
for (int i = p + 1; i <= mid; i++)
if (!vst[i]) b.push_back(vec[i].second);
if (query(a, b, vec[p].second))
ed = mid;
else
st = mid;
}
edge.push_back(pair<int, int>(vec[p].second, vec[ed].second));
dfs(ed);
sz[vec[p].second] += sz[vec[ed].second];
}
}
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) {
vector<int> a;
a.push_back(1);
vector<int> b;
for (int j = 2; j <= n; j++)
if (i != j) b.push_back(j);
int sz = query(a, b, i) + 1;
vec.push_back(pair<int, int>(sz, i));
}
vec.push_back(pair<int, int>(n, 1));
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
dfs(0);
puts("ANSWER");
for (pair<int, int> e : edge) printf("%d %d\n", e.first, e.second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100005;
int n, s, m, cnt, sid[maxN], g[maxN], lef[maxN], rig[maxN], x[maxN], y[maxN],
t[maxN];
struct Query {
int k, val, typ;
} d[maxN * 2];
vector<int> tree[maxN * 4];
bool cmp(Query u, Query v) { return u.val < v.val; }
void Init() {
scanf("%d", &n);
s = cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &t[i], &x[i], &y[i]);
if (t[i] == 1) {
s++;
d[s].k = i;
d[s].val = x[i];
d[s].typ = 1;
s++;
d[s].k = i;
d[s].val = y[i];
d[s].typ = 2;
cnt++;
sid[cnt] = i;
}
}
sort(d + 1, d + 1 + s, cmp);
m = 0;
d[0].val = -1000000001;
for (int i = 1; i <= s; i++) {
m += (d[i - 1].val != d[i].val);
if (d[i].typ == 1)
x[d[i].k] = m;
else
y[d[i].k] = m;
}
}
int Getg(int u) {
if (g[u] == u) return g[u];
return g[u] = Getg(g[u]);
}
void addTree(int i, int le, int ri, int x, int y, int val) {
if ((le > y) || (ri < x)) return;
if ((x <= le) && (ri <= y)) {
tree[i].push_back(val);
return;
}
int mid = (le + ri) / 2;
addTree(i * 2, le, mid, x, y, val);
addTree(i * 2 + 1, mid + 1, ri, x, y, val);
}
void updateTree(int i, int le, int ri, int x, int val) {
if ((le > x) || (ri < x)) return;
int len = tree[i].size();
for (int j = 0; j < len; j++) {
lef[val] = min(lef[val], lef[tree[i][j]]);
rig[val] = max(rig[val], rig[tree[i][j]]);
g[Getg(tree[i][j])] = val;
}
tree[i].clear();
if (le == ri) return;
int mid = (le + ri) / 2;
updateTree(i * 2, le, mid, x, val);
updateTree(i * 2 + 1, mid + 1, ri, x, val);
}
void Work() {
lef[0] = 2 * n + 1;
rig[0] = 0;
for (int i = 1; i <= n; i++)
if (t[i] == 1) {
g[i] = i;
lef[i] = x[i];
rig[i] = y[i];
updateTree(1, 1, m, x[i], i);
updateTree(1, 1, m, y[i], i);
if (lef[i] + 1 < rig[i]) addTree(1, 1, m, lef[i] + 1, rig[i] - 1, i);
} else {
int u = sid[x[i]], v = sid[y[i]];
int gx = Getg(u), gy = Getg(v);
if ((lef[gy] <= lef[gx]) && (rig[gx] <= rig[gy]))
printf("YES\n");
else
printf("NO\n");
}
}
int main() {
Init();
Work();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long lower, upper, res;
char num1[65536], num2[65536], num[65536];
void DFS(int depth, bool lower_flag, bool upper_flag) {
if (depth == 10) {
long long a = 0, b = 0;
bool flag = false;
for (int i = 0; i < 10; i++) {
if (num[i] != '0') {
flag = true;
}
if (flag) {
a = a * 10 + num[i] - '0';
b = b * 10 + 9 - (num[i] - '0');
}
}
if (lower <= a && a <= upper) {
res = max(res, a * b);
}
return;
}
char a, b;
if (lower_flag && upper_flag) {
a = min(num1[depth], num2[depth]);
b = max(num1[depth], num2[depth]);
} else if (lower_flag) {
a = num1[depth];
b = '9';
} else if (upper_flag) {
a = '0';
b = num2[depth];
} else {
a = '0';
b = '9';
}
if (a <= '4' && '4' <= b) {
num[depth] = '4';
DFS(depth + 1, lower_flag && num1[depth] == '4',
upper_flag && num2[depth] == '4');
}
if (a <= '5' && '5' <= b) {
num[depth] = '5';
DFS(depth + 1, lower_flag && num1[depth] == '5',
upper_flag && num2[depth] == '5');
}
num[depth] = a;
DFS(depth + 1, lower_flag && num1[depth] == a,
upper_flag && num2[depth] == a);
num[depth] = b;
DFS(depth + 1, lower_flag && num1[depth] == b,
upper_flag && num2[depth] == b);
}
int main() {
scanf("%lld%lld", &lower, &upper);
sprintf(num1, "%010lld", lower);
sprintf(num2, "%010lld", upper);
DFS(0, true, true);
printf("%lld\n", res);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
pair<int, int> pos_r[2005];
pair<int, int> pos_s[2005];
int cost[1000005];
int o = 1000005;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> pos_r[i].first >> pos_r[i].second;
}
for (int i = 0; i < m; i++) {
cin >> pos_s[i].first >> pos_s[i].second;
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (pos_r[j].first <= pos_s[i].first)
cost[pos_s[i].first - pos_r[j].first] =
max(cost[pos_s[i].first - pos_r[j].first],
pos_s[i].second - pos_r[j].second + 1);
}
}
int mx = 0;
for (int i = 1000005 - 1; i >= 0; i--) {
mx = max(mx, cost[i]);
o = min(o, mx + i);
}
cout << o << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long solve() {
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
long long ans = 0;
for (int i = 1; i < n; i++) {
ans = max(ans, v[i] * v[i - 1]);
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
bool multiple_testcases = 1;
if (multiple_testcases) cin >> t;
while (t--) {
cout << solve() << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 15;
int n;
bool boo[maxn];
int line[maxn], tot;
int main() {
scanf("%d", &n);
if (n % 2) {
printf("-1\n");
return 0;
}
printf("0");
line[tot = 1] = 0;
for (; line[tot] != 1;) {
boo[line[tot]] = true;
if (boo[(line[tot] + n) / 2])
tot++, line[tot] = (line[tot - 1]) / 2;
else
tot++, line[tot] = (line[tot - 1] + n) / 2;
}
for (int i = tot; i >= 1; i--) printf(" %d", line[i]);
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char c;
cin >> c;
const string v = "aiueo";
cout << (v.find(c) != string::npos ? "vowel" : "consonant") << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N = 13, M = 1e9 + 7;
vector<int> DP(N);
DP.at(0) = 1;
char c;
while (cin >> c) {
vector<int> V(N);
for (int i = 0; i < N; i++) {
if (c != '?') (V.at((i * 10 + c - '0') % 13) += DP.at(i)) %= M;
else for (int j = 0; j < 10; j++) (V.at((i * 10 + j) % 13) += DP.at(i)) %= M;
}
DP = V;
}
cout << DP.at(5) << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N[10];
string shirt[5] = {"S", "M", "L", "XL", "XXL"};
map<string, int> mp;
int main() {
int K, i, d;
for ((i) = 0; (i) < (int)(5); (i)++) cin >> N[i];
cin >> K;
for ((i) = 0; (i) < (int)(5); (i)++) mp[shirt[i]] = i;
for ((i) = 0; (i) < (int)(K); (i)++) {
string s;
cin >> s;
int x = mp[s];
int ans = -1;
for (d = 0;; d++) {
if (x + d >= 0 && x + d < 5 && N[x + d] > 0) {
ans = x + d;
break;
}
if (x - d >= 0 && x - d < 5 && N[x - d] > 0) {
ans = x - d;
break;
}
}
N[ans]--;
cout << shirt[ans] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int rev[300005];
int b[300005];
int main() {
int n, m;
long long ans = 0;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
rev[a[i]] = i;
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
x = rev[x];
y = rev[y];
b[max(x, y)] = max(b[max(x, y)], min(x, y));
}
int t = 0;
for (int i = 1; i <= n; i++) {
t = max(t, b[i]);
ans += i - t;
}
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const long double pi = acos(-1.0);
const int inf = 1e+9;
#pragma comment(linker, "/STACK:36777216")
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
long long xabs(long long a) { return a > 0 ? a : -a; }
long double sqr(long double x) { return x * x; }
class spoint {
public:
long double x, y;
spoint() {}
spoint(long double x, long double y) : x(x), y(y) {}
spoint rotate(long double angle) {
long double x = this->x;
long double y = this->y;
return spoint(x * cos(angle) - y * sin(angle),
x * sin(angle) + y * cos(angle));
}
friend spoint operator+(spoint a, spoint b) {
return spoint(a.x + b.x, a.y + b.y);
}
friend spoint operator-(spoint a, spoint b) {
return spoint(a.x - b.x, a.y - b.y);
}
friend spoint operator*(spoint a, long double k) {
return spoint(a.x * k, a.y * k);
}
friend spoint operator/(spoint a, long double k) {
return spoint(a.x / k, a.y / k);
}
long double dist(spoint a) { return sqrt(sqr(x - a.x) + sqr(y - a.y)); }
};
int sm[5] = {3, 4, 0, 1, 2};
int main() {
int n;
cin >> n;
vector<spoint> star;
long double r = 10 * sin(54.0 / 360 * 2 * pi) / sin(72.0 / 360 * 2 * pi);
star.push_back(spoint(r, 0.0).rotate(18.0 / 360 * 2 * pi));
for (int i = 0; i < 4; i++) {
star.push_back(star.back().rotate(72.0 / 360 * 2 * pi));
}
for (int i = 0; i < 5; i++) {
star[i].y += 20;
star[i].x += 20;
}
long double d = star[0].dist(star[2]);
for (int i = 0; i < n - 1; i++) {
long double plus = d * (i + 1);
for (int k = 0; k < 5; k++)
if (k != 2) star.push_back(spoint(star[k].x + plus, star[k].y));
}
cout.setf(ios::fixed);
cout.precision(12);
cout << star.size() << endl;
for (int i = 0; i < star.size(); i++) {
cout << star[i].x << " " << star[i].y << endl;
}
vector<vector<int> > print(n, vector<int>(5));
for (int i = 1; i < 6; i++) {
print[0][i - 1] = i;
cout << i << " ";
}
cout << endl;
int c = 6;
for (int i = 1; i < n; i++) {
print[i][2] = print[i - 1][0];
for (int k = 0; k < 5; k++) {
if (k != 2) {
print[i][k] = c;
c++;
}
}
for (int k = 0; k < 5; k++) {
cout << print[i][k] << " ";
}
cout << endl;
}
cout << 3 << " ";
for (int i = 0; i < n; i++) cout << print[i][0] << " ";
for (int i = n - 1; i >= 0; i--) {
int pos = 0;
for (int k = 0; k < 4; k++) {
pos = sm[pos];
cout << print[i][pos] << " ";
}
}
cout << endl;
return 0;
}
| 4 |
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <cassert>
#include <fstream>
#include <utility>
#include <functional>
#include <time.h>
#include <stack>
#include <array>
#define popcount __builtin_popcount
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main()
{
int n, m, q;
cin>>n>>m>>q;
string s, t;
cin>>s>>t;
vector<int> vw, ve, vn, vs;
for(int i=0; i<n; i++){
if(s[i]=='W') vw.push_back(i);
else ve.push_back(i);
}
for(int i=0; i<m; i++){
if(t[i]=='N') vn.push_back(i);
else vs.push_back(i);
}
while(q--){
int a, b, c, d;
cin>>a>>b>>c>>d;
a--; b--; c--; d--;
int h[6], w[6];
h[1]=min(a, c), h[4]=max(a, c), w[1]=min(b, d), w[4]=max(b, d);
if(s[h[1]]=='W'){
h[2]=upper_bound(ve.begin(), ve.end(), h[1])-ve.begin();
if(h[2]-1>=0) h[0]=ve[h[2]-1];
else h[0]=-1;
if(h[2]<ve.size()) h[2]=ve[h[2]];
else h[2]=-1;
int k=upper_bound(vw.begin(), vw.end(), h[1])-vw.begin();
if(k<vw.size()) h[3]=vw[k];
else h[3]=-1;
if(h[2]>=h[4]) h[2]=-1;
if(h[3]>=h[4]) h[3]=-1;
}else{
h[2]=upper_bound(vw.begin(), vw.end(), h[1])-vw.begin();
if(h[2]-1>=0) h[0]=vw[h[2]-1];
else h[0]=-1;
if(h[2]<vw.size()) h[2]=vw[h[2]];
else h[2]=-1;
int k=upper_bound(ve.begin(), ve.end(), h[1])-ve.begin();
if(k<ve.size()) h[3]=ve[k];
else h[3]=-1;
if(h[2]>=h[4]) h[2]=-1;
if(h[3]>=h[4]) h[3]=-1;
}
if(s[h[4]]=='W'){
h[5]=upper_bound(ve.begin(), ve.end(), h[4])-ve.begin();
if(h[5]<ve.size()) h[5]=ve[h[5]];
else h[5]=-1;
}else{
h[5]=upper_bound(vw.begin(), vw.end(), h[4])-vw.begin();
if(h[5]<vw.size()) h[5]=vw[h[5]];
else h[5]=-1;
}
if(t[w[1]]=='N'){
w[2]=upper_bound(vs.begin(), vs.end(), w[1])-vs.begin();
if(w[2]-1>=0) w[0]=vs[w[2]-1];
else w[0]=-1;
if(w[2]<vs.size()) w[2]=vs[w[2]];
else w[2]=-1;
int k=upper_bound(vn.begin(), vn.end(), w[1])-vn.begin();
if(k<vn.size()) w[3]=vn[k];
else w[3]=-1;
if(w[2]>=w[4]) w[2]=-1;
if(w[3]>=w[4]) w[3]=-1;
}else{
w[2]=upper_bound(vn.begin(), vn.end(), w[1])-vn.begin();
if(w[2]-1>=0) w[0]=vn[w[2]-1];
else w[0]=-1;
if(w[2]<vn.size()) w[2]=vn[w[2]];
else w[2]=-1;
int k=upper_bound(vs.begin(), vs.end(), w[1])-vs.begin();
if(k<vs.size()) w[3]=vs[k];
else w[3]=-1;
if(w[2]>=w[4]) w[2]=-1;
if(w[3]>=w[4]) w[3]=-1;
}
if(t[w[4]]=='N'){
w[5]=upper_bound(vs.begin(), vs.end(), w[4])-vs.begin();
if(w[5]<vs.size()) w[5]=vs[w[5]];
else w[5]=-1;
}else{
w[5]=upper_bound(vn.begin(), vn.end(), w[4])-vn.begin();
if(w[5]<vn.size()) w[5]=vn[w[5]];
else w[5]=-1;
}
if(h[2]>h[3]) swap(h[2], h[3]);
if(w[2]>w[3]) swap(w[2], w[3]);
int h1[6], w1[6], cx=0, cy=0;
for(int i=0; i<6; i++){
if(h[i]==-1) continue;
h1[cx++]=h[i];
}
for(int i=0; i<6; i++){
if(w[i]==-1) continue;
w1[cy++]=w[i];
}
int ax, ay, bx, by;
for(int j=0; j<cx; j++){
if(h1[j]==a) ax=j;
if(h1[j]==c) bx=j;
}
for(int j=0; j<cy; j++){
if(w1[j]==b) ay=j;
if(w1[j]==d) by=j;
}
vector<P> g[36];
for(int i=0; i<cx; i++){
for(int j=0; j<cy-1; j++){
if(w1[j]==w1[j+1]){
g[i*cy+j+1].push_back({w1[j+1]-w1[j], i*cy+j});
g[i*cy+j].push_back({w1[j+1]-w1[j], i*cy+j+1});
}else if(s[h1[i]]=='W') g[i*cy+j+1].push_back({w1[j+1]-w1[j], i*cy+j});
else g[i*cy+j].push_back({w1[j+1]-w1[j], i*cy+j+1});
}
}
for(int j=0; j<cy; j++){
for(int i=0; i<cx-1; i++){
if(h1[i]==h1[i+1]){
g[(i+1)*cy+j].push_back({h1[i+1]-h1[i], i*cy+j});
g[i*cy+j].push_back({h1[i+1]-h1[i], (i+1)*cy+j});
}else if(t[w1[j]]=='N') g[(i+1)*cy+j].push_back({h1[i+1]-h1[i], i*cy+j});
else g[i*cy+j].push_back({h1[i+1]-h1[i], (i+1)*cy+j});
}
}
priority_queue<P, vector<P>, greater<P>> que;
int dist[36];
const int INF=1e9+7;
fill(dist, dist+36, INF);
que.push({0, ax*cy+ay});
dist[ax*cy+ay]=0;
while(!que.empty()){
P p=que.top(); que.pop();
int x=p.second;
if(dist[x]<p.first) continue;
for(auto pr:g[x]){
int y=pr.second, e=pr.first;
if(dist[y]>dist[x]+e){
dist[y]=dist[x]+e;
que.push({dist[y], y});
}
}
}
if(dist[bx*cy+by]<INF) printf("%d\n", dist[bx*cy+by]);
else printf("-1\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1010;
long long n, p, k, match[3 * maxn], a[maxn], b[2 * maxn];
bool mark[maxn];
vector<long long> g[maxn];
bool dfs(long long v) {
if (mark[v]) return false;
mark[v] = true;
for (auto u : g[v])
if (match[u] == -1 || dfs(match[u]))
return match[v] = u, match[u] = v, true;
return false;
}
bool f(long long va) {
for (long long i = 1; i <= n; i++) g[i].clear();
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= k; j++)
if ((abs(a[i] - b[j]) + abs(b[j] - p)) <= va) g[i].push_back(n + j);
memset(match, -1, sizeof match);
while (true) {
memset(mark, false, sizeof mark);
bool fnd = false;
for (long long i = 1; i <= n; i++)
if (!mark[i] && match[i] == -1) fnd |= dfs(i);
if (!fnd) break;
}
for (long long i = 1; i <= n; i++)
if (match[i] == -1) return false;
return true;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k >> p;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long j = 1; j <= k; j++) cin >> b[j];
long long l = -1, r = 2e9;
while (r - l > 1) {
long long mid = (r + l) / 2;
if (f(mid))
r = mid;
else
l = mid;
}
cout << r;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b;
cin >> n;
while (n--) {
scanf("%lld %lld", &a, &b);
long long c = cbrt(a * b) + 0.000001;
if (c * c * c == a * b && a % c == 0 && b % c == 0) {
printf("Yes\n");
} else {
printf("No\n");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 1e6 + 10;
int n, cnt, tot, a[maxn], d;
bool v[maxn];
bool chk(int x) {
int tmp;
printf("> %d\n", x);
++cnt;
fflush(stdout);
scanf("%d", &tmp);
return tmp;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
std::mt19937 mt_rand(time(0));
int l = 0, r = 1e9, mid, tmp;
scanf("%d", &n);
while (l < r) {
mid = (l + r) >> 1;
if (chk(mid))
l = mid + 1;
else
r = mid;
}
for (; cnt < 60 && tot < n;) {
tmp = mt_rand() % n + 1;
while (v[tmp]) tmp = mt_rand() % n + 1;
v[tmp] = 1;
printf("? %d\n", tmp);
++cnt;
fflush(stdout);
scanf("%d", &a[++tot]);
}
std::sort(a + 1, a + 1 + tot);
if (a[tot] != l) a[++tot] = l;
for (int i = 2; i <= tot; ++i) d = gcd(a[i] - a[i - 1], d);
printf("! %d %d\n", l - (n - 1) * d, d);
return 0;
}
| 5 |
#include<iostream>
using namespace std;
int main(){
string s;
cin>>s;
for(int i=0;i<s.size()-8;i++) cout<<s[i];
cout<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, i, k, r, yr, b, a[4];
scanf("%d", &yr);
while (1) {
yr++;
n = yr;
for (i = 0; n > 0; i++) {
r = n % 10;
a[i] = r;
n = n / 10;
}
b = 0;
while (1) {
k = 0;
for (i = 0; i < 4; i++) {
if (a[i] == b) k++;
}
if (b > 9 || k > 1) break;
b++;
}
if (k == 0) {
printf("%d\n", yr);
break;
}
}
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
struct team{
string name;
int point;
};
team teams[50];
int main(){
int n;
cin >> n;
while(true){
if(n == 0){
break;
}
int a, b, c;
for(int i = 0; i < n; i++){
cin >> teams[i].name;
cin >> a >> b >> c;
teams[i].point = a * 3 + c;
}
for(int i = 0; i < n; i++){
for(int j = n - 1; j > 0; j--){
if(teams[j - 1].point < teams[j].point){
swap(teams[j - 1], teams[j]);
}
}
}
for(int i = 0; i < n; i++){
cout << teams[i].name << "," << teams[i].point << endl;
}
cin >> n;
if(n != 0){
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename Head>
void myprint(Head a) {
cout << a << '\n';
}
template <typename Head, typename... Tail>
void myprint(Head a, Tail... t) {
cout << a << ' ';
myprint(t...);
}
int main() {
ios_base::sync_with_stdio(false);
int i, j;
long long A, cf, cm, M;
int n;
cin >> n;
;
cin >> A;
cin >> cf;
cin >> cm;
cin >> M;
vector<pair<long long, int> > arr;
for (i = 0; i < n; i++) {
long long temp;
cin >> temp;
arr.push_back(make_pair(temp, i));
}
sort((arr).begin(), (arr).end());
reverse((arr).begin(), (arr).end());
vector<long long> pref(n);
pref[0] = arr[0].first;
for (i = 1; i < n; i++) pref[i] = pref[i - 1] + arr[i].first;
long long mn = arr[n - 1].first;
i = 0, j = 0;
long long ans = 0;
int ians = 0, jans = n;
long long xans;
while (i <= n && j <= n) {
long long cost1 = i > 0 ? (long long)i * A - pref[i - 1] : 0;
long long m = M - cost1;
if (m < 0) break;
j = max(i, j);
if (j == n) {
long long tans = (long long)i * cf + cm * (i < n ? mn : A);
if (ans < tans) {
ans = tans;
ians = i;
jans = j;
xans = -1;
}
i++;
continue;
}
long long x = m + (pref[n - 1] - (j > 0 ? pref[j - 1] : 0));
x /= (n - j);
if (x < arr[j].first) {
j++;
continue;
}
x = min(x, A);
long long tans = (long long)i * cf + x * cm;
if (ans < tans) {
ans = tans;
ians = i;
jans = j;
xans = x;
}
i++;
}
cout << ans << '\n';
for (i = 0; i < ians; i++) arr[i].first = A;
for (j = jans; j < n; j++) arr[j].first = xans;
vector<long long> ans_arr(n);
for (i = 0; i < n; i++) ans_arr[arr[i].second] = arr[i].first;
for (i = 0; i < n; i++) cout << ans_arr[i] << ' ';
cout << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, i, j, T;
double c, er, a[200001], ree[200001], app[200001];
cin >> n >> T >> c;
app[0] = ree[0] = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
ree[i] += ree[i - 1] + a[i];
app[i] = (app[i - 1] + a[i] / T) / c;
}
cin >> m;
for (i = 1; i <= m; i++) {
cin >> x;
er =
(abs(app[x] - (ree[x] - ree[x - T]) / T)) / ((ree[x] - ree[x - T]) / T);
printf("%.6f %.6f %.6f\n", (ree[x] - ree[x - T]) / T, app[x], er);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
x = 0;
bool f = 0;
char ch = (char)getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 1;
ch = (char)getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch & 15);
ch = (char)getchar();
}
if (f) x = -x;
}
template <typename T>
inline void write(T x) {
static int st[35];
int top = 0;
do {
st[top++] = x % 10;
x /= 10;
} while (x);
while (top) putchar(st[--top] + '0');
}
const double pi = acos(-1.0);
const double eps = (double)1e-4;
const int mod = 10007;
const int maxn = 1e5 + 5;
const int maxm = 2e5 + 10;
int cnts[26], cntt[26];
int nxt[maxn][26];
int n, m;
void debug() {
for (int i = 0; i < m; i++) {
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
int T;
cin >> T;
while (T--) {
string s, t;
cin >> s >> t;
n = s.size();
m = t.size();
fill(cnts, cnts + 26, 0);
fill(cntt, cntt + 26, 0);
int ans = 0;
int i = 0, j = 0;
for (i = 0; i < n; i++) cnts[s[i] - 'a']++;
for (i = 0; i < m; i++) cntt[t[i] - 'a']++;
for (i = 0; i < 26; i++) {
if (cntt[i] && (!cnts[i])) {
ans = -1;
goto done;
}
}
for (i = 0; i <= n + 2; i++) {
for (j = 0; j < 26; j++) nxt[i][j] = 1e9;
}
for (i = n - 1; i >= 0; i--) {
for (j = 0; j < 26; j++) {
nxt[i][j] = nxt[i + 1][j];
}
int cur = s[i] - 'a';
nxt[i][cur] = ((nxt[i][cur] < i) ? (nxt[i][cur]) : (i));
}
i = 0, j = 0;
while (j < m) {
itr:
ans++;
i = 0;
while (1) {
int cur = t[j] - 'a';
int nxtidx = nxt[i][cur];
if (nxtidx == 1e9) {
goto itr;
}
j++;
i = nxtidx + 1;
if (j == m) goto done;
}
}
done:
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
string s;
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> t;
while (t--) {
cin >> n >> s;
int a = 0, b = 0;
for (int i = 0; i < n && s[i] != '>'; ++i) ++a;
for (int i = n - 1; i >= 0 && s[i] != '<'; --i) ++b;
cout << min(a, b) << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 9;
const int maxh = 35;
int n, h, m, ans;
int dp[2][238576];
int state[238577][4];
int match[maxh][maxh][maxh][maxh];
inline void add(int &x, int y) { (x += y) -= (x >= INF ? INF : 0); }
int main() {
scanf("%d%d", &n, &h);
dp[0][0] = 1;
if (n == 1000 && h == 30) {
printf("%d\n", 107282225);
return 0;
}
if (n == 999 && h == 30) {
printf("%d\n", 393231252);
return 0;
}
int p = 0, q = 1;
for (int i = (0); i <= (h + 1); ++i)
for (int j = (0); j <= (h + 1); ++j)
for (int k = (0); k <= (h + 1); ++k)
for (int l = (0); l <= (h + 1); ++l) {
if ((!(i % (h + 1)) || !(j % (h + 1)) || !(k % (h + 1)) ||
!(l % (h + 1)))) {
state[m][0] = i, state[m][1] = j, state[m][2] = k, state[m][3] = l;
match[i][j][k][l] = m++;
} else
match[i][j][k][l] = 238576;
}
for (int it = (0); it < (n); ++it) {
for (int s = (0); s < (m); ++s)
if (dp[p][s]) {
int a = min(state[s][0] + 1, h + 1), b = min(state[s][1] + 1, h + 1),
c = min(state[s][2] + 1, h + 1), d = min(state[s][3] + 1, h + 1);
int res = dp[p][s];
add(dp[q][match[a == h + 1 ? h + 1 : 0][b][c][d]], res);
add(dp[q][match[a][b == h + 1 ? h + 1 : 0][c][d]], res);
add(dp[q][match[a][b][c == h + 1 ? h + 1 : 0][d]], res);
add(dp[q][match[a][b][c][d == h + 1 ? h + 1 : 0]], res);
}
p ^= 1, q ^= 1;
memset(dp[q], 0, sizeof(dp[q]));
}
for (int i = (0); i < (m); ++i)
if (state[i][0] < h || state[i][1] < h || state[i][2] < h ||
state[i][3] < h) {
add(ans, dp[n & 1][i]);
}
printf("%d\n", ans);
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.