solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int const MAX_N = 100005;
int const MAX_M = 100005;
int const MAX_K = 507;
int const INF = 0x3F3F3F3F;
int const NA = -1;
int d[MAX_N];
int e[MAX_N];
int u[MAX_M];
int v[MAX_M];
int w[MAX_M];
int c[MAX_K];
int a[MAX_K][MAX_K];
int up(int p) {
if (e[p] == p) {
return p;
}
return (e[p] = up(e[p]));
}
void unite(int p, int q) {
p = up(p);
q = up(q);
if (p != q) {
e[p] = q;
}
}
int main(void) {
int n, m, k;
while (scanf(" %d %d %d", &n, &m, &k) != EOF) {
int p = 0;
for (int i = 0; i < k; i++) {
scanf(" %d", &c[i]);
for (int j = 0; j < c[i]; j++) {
d[p] = i;
p++;
}
}
for (int i = 0; i < n; i++) {
e[i] = i;
}
for (int j = 0; j < m; j++) {
scanf(" %d %d %d", &u[j], &v[j], &w[j]);
u[j]--;
v[j]--;
if (w[j] == 0) {
unite(u[j], v[j]);
}
}
bool ok = true;
for (int i = 1; i < n; i++) {
if ((d[i - 1] == d[i]) && (up(e[i - 1]) != up(e[i]))) {
ok = false;
}
}
if (!ok) {
printf("No\n");
continue;
}
printf("Yes\n");
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
a[i][j] = INF * (i != j);
}
}
for (int j = 0; j < m; j++) {
a[d[u[j]]][d[v[j]]] = min(a[d[u[j]]][d[v[j]]], w[j]);
a[d[v[j]]][d[u[j]]] = min(a[d[v[j]]][d[u[j]]], w[j]);
}
for (int l = 0; l < k; l++) {
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
a[i][j] = min(a[i][j], a[i][l] + a[l][j]);
}
}
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
printf("%d%c", (a[i][j] < INF) ? a[i][j] : NA, "\n "[j + 1 < k]);
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 9];
for (int i = 0; i < n; i++) cin >> a[i];
int j = 0;
while (a[j] == 0) j++;
int k = n - 1;
while (a[k] == 0) k--;
int count = 0, cnt = 0;
for (int i = j; i <= k; i++) {
if (a[i] == 1)
count++;
else {
cnt++;
while (a[i] == 0) i++;
i--;
}
}
cout << (count + cnt) << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s, t; cin >> s >> t;
int c = 0;
for (int i = 0; i < s.size(); ++i)
if (s[i] != t[i])
c++;
cout << c << endl;
}
| 0 |
#include <bits/stdc++.h>
const long long inf = 0x3f3f3f3f3f3f3f3fll;
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int main() {
long long n, k, sum = 0, i;
cin >> n >> k;
set<long long> s;
long long ans[n];
vector<pair<long long, long long> > v(n);
for (i = 0; i < n; i++) {
cin >> v[i].first;
v[i].second = i + 1;
s.insert(i + 1 + k);
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (i = 0; i < n; i++) {
auto it = s.lower_bound(v[i].second);
ans[v[i].second - 1] = *it;
sum += (*it - v[i].second) * v[i].first;
s.erase(it);
}
cout << sum << endl;
for (i = 0; i < n; i++) cout << ans[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > vs;
int getCode(int x, int y) { return (1 << (3 * x + (2 - y))); }
int n, cost[5], step, col[1010], dp[4096][1010];
string str[4];
int main() {
ios_base::sync_with_stdio(false);
for (int i = 0; i < 4; i++) step |= getCode(i, 0);
cin >> n;
for (int i = 1; i <= 4; i++) cin >> cost[i];
for (int i = 0; i < 4; i++) cin >> str[i];
for (int j = 0; j < n; j++)
for (int i = 0; i < 4; i++)
if (str[i][j] == '*') col[j] |= getCode(i, 2);
for (int i = 0; i < 4; i++)
for (int j = 0; j < 3; j++)
for (int k = 1; i + k <= 4 && j + k <= 3; k++) {
vs.push_back((make_pair((0), (cost[k]))));
for (int x = i; x < i + k; x++)
for (int y = j; y < j + k; y++) vs.back().first |= getCode(x, y);
}
for (int i = 0; i < 4096; i++) fill(dp[i], dp[i] + 1010, 2147483647);
dp[col[0]][0] = 0;
int res = 2147483647;
for (int j = 0, m, c, m_; j < n; j++) {
for (int mask = 4095; mask >= 0; mask--) {
if (dp[mask][j] == 2147483647) continue;
for (auto v : vs) {
tie(m, c) = v;
m_ = (mask | m) ^ m;
dp[m_][j] = min(dp[m_][j], dp[mask][j] + c);
}
if (j >= 2) dp[0][j + 1] = min(dp[0][j + 1], dp[mask][j] + cost[4]);
if ((mask & step) == 0)
dp[(mask << 1) | col[j + 1]][j + 1] =
min(dp[(mask << 1) | col[j + 1]][j + 1], dp[mask][j]);
}
}
cout << min(res, dp[0][n]) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int mod = 1e9 + 7;
int n;
pair<long long, int> a[N];
long long bit_a[N], bit_b[N];
void add(long long bit[], int x, long long y) {
while (x < N) {
bit[x] = (bit[x] + y) % mod;
x += x & -x;
}
}
long long sum(long long bit[], int x) {
long long s = 0;
while (x) {
s = (s + bit[x]) % mod;
x -= x & -x;
}
return s;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i].first);
a[i].second = i;
}
sort(a + 1, a + n + 1);
long long res = 0;
for (int i = 1; i <= n; i++) {
int ind = a[i].second;
long long val = a[i].first;
res = (res + 1ll * ind * (n - ind + 1) % mod * val) % mod;
res = (res + sum(bit_a, ind) * 1ll * (n - ind + 1) % mod * val) % mod;
add(bit_a, ind, ind * 1ll);
res = (res +
1ll * ind * (sum(bit_b, n) - sum(bit_b, ind) + mod) % mod * val) %
mod;
add(bit_b, ind, (n - ind + 1) * 1ll);
}
printf("%lld\n", res % mod);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void printarr(int arr[], int n) {
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
void printarr(vector<int> arr) {
int n = arr.size();
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long test, ti, n, i;
cin >> n;
long long x[n], h[n], g[n + 1];
g[0] = INT_MAX;
g[n] = INT_MAX;
for (int i = 0; i < (n); i++) cin >> x[i] >> h[i];
for (int i = (1); i < (n); i++) g[i] = x[i] - x[i - 1];
long long cnt = 0;
for (int i = 0; i < (n); i++) {
if (h[i] < g[i])
cnt++;
else if (h[i] < g[i + 1]) {
cnt++;
g[i + 1] -= h[i];
}
}
cout << cnt << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
bool dfs(string s){
if(s=="AKIHABARA") return true;
if(s.length()>=9) return false;
rep(i,s.length()+1) if(dfs(s.substr(0,i)+"A"+s.substr(i))) return true;
return false;
}
int main(){
string s; cin>>s;
puts(dfs(s)?"YES":"NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int i, len, count4 = 0, one = 0;
char str[20];
scanf("%s", str);
len = strlen(str);
for (i = 0; i < len; i++) {
if (str[i] == '1')
one = 1;
else if (str[i] == '4') {
while (str[i] == '4') {
count4++;
i++;
}
i--;
} else {
one = 0;
break;
}
if (count4 > 2) {
one = 0;
count4 = 0;
break;
} else
count4 = 0;
}
if (one == 0 || str[0] != '1')
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 1 |
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
char s[500050];
int n,mx[500050];
long long ans;
int main()
{
scanf("%s",s+1);
n=strlen(s+1)+1;
for(int i=2;i<=n;++i)if(s[i-1]=='<')mx[i]=mx[i-1]+1;
for(int i=n-1;i;--i)
if(s[i]=='>')mx[i]=max(mx[i],mx[i+1]+1);
for(int i=1;i<=n;++i)ans+=mx[i];
printf("%lld",ans);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){long long int n,k,s,i,c;
cin>>n>>k>>s;
long long int a[n];
c=1000000000;
if(s==c){c=1;}
for(i=0;i<n;i++){a[i]=c;}
for(i=0;i<k;i++){a[i]=s;}
for(i=0;i<n;i++){cout<<a[i]<<" ";}
return 0;} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
/* 平面幾何の基本要素 */
#define EPS (1e-10)
#define equals(a,b) (fabs((a) - (b)) < EPS )
#define PI 3.141692653589793
class Point { // 点を表すクラス
public:
double x,y;
Point(double x=0,double y=0): x(x),y(y) {}
Point operator + (Point p) { return Point(x + p.x, y + p.y); }
Point operator - (Point p) { return Point(x - p.x, y - p.y); }
Point operator * (double a) { return Point(a * x, a * y); }
Point operator / (double a) { return Point(x / a, y / a); }
double abs() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator < (const Point &p) const {
return x != p.x ? x < p.x : y < p.y;
}
bool operator == (const Point &p) const {
return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
}
};
typedef Point Vector; // ベクトルを表す構造体
struct Segment { // 線分を表す構造体
Point p1,p2;
};
typedef Segment Line; // 直線を表す構造体
class Circle { // 円を表すクラス
public:
Point c;
double r;
Circle(Point c = Point(), double r = 0.0): c(c),r(r) {}
};
typedef vector < Point > Polygon; // 多角形
double dot(Vector a, Vector b) {
return a.x * b.x + a.y * b.y;
}
double cross(Vector a, Vector b) {
return a.x * b.y - a.y * b.x;
}
int H,R;
Point h[111];
int U,M,S;
double du,dm,ds;
Point u[11],m[11],s[11];
double w[111],a[111];
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
int ccw(Point p0, Point p1, Point p2) {
Vector a = p1 - p0;
Vector b = p2 - p0;
if( cross(a,b) > EPS ) return COUNTER_CLOCKWISE;
if( cross(a,b) < -EPS ) return CLOCKWISE;
if( dot(a,b) < -EPS ) return ONLINE_BACK;
if( a.norm() < b.norm() ) return ONLINE_FRONT;
return ON_SEGMENT;
}
bool judge(Point p,int hn,int wn,double rad){
double length = sqrt((p.x-h[hn].x)*(p.x-h[hn].x)+(p.y-h[hn].y)*(p.y-h[hn].y));
if(length > a[wn]) return false;
Point p1,p2;
p1.x = a[wn]*cos((w[wn]-rad/2)*PI/180.0)+p.x;
p1.y = a[wn]*sin((w[wn]-rad/2)*PI/180.0)+p.y;
p2.x = a[wn]*cos((w[wn]+rad/2)*PI/180.0)+p.x;
p2.y = a[wn]*sin((w[wn]+rad/2)*PI/180.0)+p.y;
//cout<<p.x<<" "<<p.y<<" "<<p1.x<<" "<<p1.y<<" "<<p2.x<<" "<<p2.y<<endl;
//cout << ccw(p,p1,h[hn]) << " " << ccw(p,p2,h[hn]) << endl;
if(ccw(p,p1,h[hn]) == 1 && ccw(p,p2,h[hn]) == -1) return true;
return false;
}
int main(){
while(cin >> H >> R , H){
for(int i=0;i<H;i++) cin >> h[i].x >> h[i].y;
cin >> U >> M >> S >> du >> dm >> ds;
for(int i=0;i<U;i++) cin >> u[i].x >> u[i].y;
for(int i=0;i<M;i++) cin >> m[i].x >> m[i].y;
for(int i=0;i<S;i++) cin >> s[i].x >> s[i].y;
for(int i=0;i<R;i++) cin >> w[i] >> a[i];
Point T; T.x = 0; T.y = 0;
P cnt[111];
for(int i=0;i<111;i++){
cnt[i].first = 0;
cnt[i].second = -(i+1);
}
for(int i=0;i<H;i++){
for(int j=0;j<R;j++){
if(judge(T,i,j,du)){
bool flg = true;
for(int k=0;k<U;k++){
if(judge(u[k],i,j,du)) {
flg = false;
break;
}
}
if(flg){
for(int k=0;k<M;k++){
if(judge(m[k],i,j,dm)) {
flg = false;
break;
}
}
}
if(flg){
for(int k=0;k<S;k++){
if(judge(s[k],i,j,ds)) {
flg = false;
break;
}
}
}
if(flg) {
cnt[i].first++;
}
}
}
}
sort(cnt,cnt+H,greater<P>() );
int maxx = cnt[0].first;
int idx = 0;
if(cnt[0].first == 0) cout << "NA" << endl;
else {
while(maxx == cnt[idx].first){
cout << -cnt[idx].second;
if(cnt[idx+1].first == maxx) cout << " ";
else cout << endl;
idx++;
}
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s,t;
cin >> s >> t;
vector<int> a,b;
int k=0;
for(int i=0; i<s.size(); i++) {
if(k<t.size()&&s[i]==t[k]) {
a.push_back(i);
k++;
}
}
k=t.size()-1;
for(int i=s.size()-1; i>=0; i--) {
if(k>=0&&s[i]==t[k]) {
b.push_back(i);
k--;
}
}
reverse(b.begin(),b.end());
if(a.size()==t.size()&&a==b) cout << "yes" << endl;
else cout << "no" << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define int long long int
const int mod=1e9+7;
#define fastinout ios_base::sync_with_stdio(false); cin.tie(NULL);
using namespace std;
int power(int x, int y, int p)
{
int res = 1;
x = x % p;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int imod(int a, int m)
{
return power(a, m - 2, m);
}
void myfun()
{
int n,i,m,ans=0;
cin>>n>>m;
string s,t;
cin>>s>>t;
int j=0;
int arr[m],brr[m];
for(i=0;i<n && j<m;i++)
{
if(s[i]==t[j])
{
arr[j]=i;
j++;
}
}
j=m-1;
for(i=n-1;i>=0 && j>=0;i--)
{
if(s[i]==t[j])
{
brr[j]=i;
j--;
}
}
for(i=1;i<m;i++)
{
ans=max(brr[i]-arr[i-1],ans);
}
cout<<ans<<"\n";
}
signed main()
{
fastinout;
int t=1;
//cin>>t;
while(t--)
myfun();
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
if(N%100<=(N/100)*5 && N>=100)
cout << 1 << endl;
else
cout << 0 << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int maxn=5*1e5+10;
const int mod=1e9+7;
int n,m,ans,delta,sum0;
int a[maxn],sum1[maxn],sum2[maxn],sum3[maxn],fac[maxn];
bool vis[maxn];
struct Tree_arry
{
#define lowbit(x) (x&-x)
int a[maxn];
inline void add(int x,int k){for(int i=x;i<=n;i+=lowbit(i))a[i]+=k;}
inline int query(int x){int res=0;for(int i=x;i;i-=lowbit(i))res+=a[i];return res;}
}tr;
signed main()
{
//freopen("test.in","r",stdin);
// freopen("test.out","w",stdout);
scanf("%lld",&n);
fac[0]=1;for(int i=1;i<=n;i++)fac[i]=(fac[i-1]*i)%mod;
for(int i=1;i<=n;i++)scanf("%lld",&a[i]),vis[a[i]]=1;
for(int i=1;i<=n;i++)sum1[i]=sum1[i-1]+(!vis[i]);//ÕýÏò
for(int i=n;i;i--)sum2[i]=sum2[i+1]+(!vis[i]);//·´Ïò
for(int i=1;i<=n;i++)sum3[i]=sum3[i-1]+(!a[i]);//0µÄ¸öÊý
m=sum3[n];
for(int i=1;i<=n;i++)if(!vis[i])sum0=(sum0+i-1)%mod;
for(int i=1;i<=n;i++)
{
int res=0;
if(a[i])
{
tr.add(a[i],1);
res=(res+(a[i]-tr.query(a[i])+mod)%mod*fac[m]%mod)%mod;
if(m)res=(res-sum3[i]*sum1[a[i]]%mod*fac[m-1]%mod+mod)%mod;
delta=(delta+sum2[a[i]])%mod;
}
else
{
res=(res+(sum0-delta+mod)%mod*fac[m-1]%mod)%mod;
if(m>=2)res=(res-m*(m-1)/2%mod*sum3[i-1]%mod*fac[m-2]%mod)%mod;
}
ans=(ans+res*fac[n-i]%mod)%mod;
}
printf("%lld",((ans+fac[m])%mod+mod)%mod);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sum1 = 0, sum2 = 0, sumx = 0;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int i = 0, j = n - 1;
sum1 = arr[i];
sum2 = arr[j];
while (i != j) {
if (sum1 == sum2) {
if (sum1 > sumx) {
sumx = sum1;
}
if (j - 1 > i + 1) {
sum1 += arr[i + 1];
sum2 += arr[j - 1];
i++;
j--;
continue;
} else
break;
} else if (sum1 > sum2) {
if (j - 1 > i) {
sum2 += arr[j - 1];
j--;
continue;
} else
break;
} else if (sum1 < sum2) {
if (j > i + 1) {
sum1 += arr[i + 1];
i++;
continue;
} else
break;
}
}
cout << sumx;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
vector<int> v(n);
vector<int> res(n);
vector<bool> lst(n);
vector<int> pos;
int k = 0;
cin >> v[0];
res[0] = v[0];
lst[v[0] - 1] = true;
for (int j = 1; j < n; j++) {
cin >> v[j];
if (v[j] != v[j - 1]) {
res[j] = v[j];
lst[v[j] - 1] = true;
}
}
for (int j = 0; j < n; j++) {
if (!lst[j]) {
pos.push_back(j);
}
}
bool flag = false;
for (int j = 0; j < n; j++) {
if (res[j] != 0) {
continue;
}
if (res[j] == 0) {
if (pos[k] + 1 < v[j]) {
res[j] = pos[k] + 1;
k++;
}
if (res[j] == 0) {
flag = true;
j = n;
}
}
}
if (flag) {
cout << -1 << endl;
continue;
}
for (int j = 0; j < n; j++) {
cout << res[j] << ' ';
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int K = 7;
const int N = 200500;
int n, k;
int sz[K][N], ups[K][N];
long long len[K][N], ways[K][N];
long long f[K][N], fuh[K][N], f1[K][N], fup[K][N];
vector<int> g[N];
void dfs(int ver, int prev) {
f[0][ver] = 1;
sz[0][ver] = 1;
for (int i = 0; i < (int)g[ver].size(); i++) {
int to = g[ver][i];
if (to != prev) {
dfs(to, ver);
for (int j = 0; j < k; j++) {
sz[(j + 1) % k][ver] += sz[j][to];
f[(j + 1) % k][ver] += f[j][to];
f1[(j + 1) % k][ver] += (f1[j][to] + 1LL * sz[j][to]);
}
}
}
}
void dfs_up(int ver, int prev) {
++fup[0][ver];
++ups[0][ver];
long long all[k];
long long kek[k];
int ps[k];
for (int j = 0; j < k; ++j) ps[j] = 0;
for (int j = 0; j < k; ++j) all[j] = kek[j] = 0LL;
for (int i = 0; i < (int)g[ver].size(); i++) {
int to = g[ver][i];
if (to != prev) {
for (int j = 0; j < k; j++) {
all[j] += f[j][to];
ps[j] += sz[j][to];
kek[j] += f1[j][to];
}
}
}
for (int i = 0; i < (int)g[ver].size(); i++) {
int to = g[ver][i];
if (to == prev) {
continue;
}
for (int j = 0; j < k; j++) {
all[j] -= f[j][to];
ps[j] -= sz[j][to];
kek[j] -= f1[j][to];
}
for (int j = 0; j < k; j++) {
fup[(j + 2) % k][to] += all[j];
fup[(j + 1) % k][to] += fup[j][ver];
fuh[(j + 2) % k][to] += (kek[j] + 2LL * ps[j]);
fuh[(j + 1) % k][to] += (fuh[j][ver] + 1LL * ups[j][ver]);
ups[(j + 1) % k][to] += ups[j][ver];
ups[(j + 2) % k][to] += ps[j];
}
for (int j = 0; j < k; j++) {
all[j] += f[j][to];
ps[j] += sz[j][to];
kek[j] += f1[j][to];
}
}
for (int i = 0; i < (int)g[ver].size(); i++) {
int to = g[ver][i];
if (to != prev) {
dfs_up(to, ver);
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 1);
dfs_up(1, 1);
long long ans = 0LL;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < k; j++) {
ways[j][i] = f[j][i] + fup[j][i];
len[j][i] = f1[j][i] + fuh[j][i];
ans =
ans + (len[j][i] - ways[j][i] * j) / k + 1LL * ways[j][i] * (j != 0);
}
}
ans /= 2LL;
cout << ans;
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double ZERO = 1e-15;
const long double EPS = 1e-10;
const int MAXN = 100500;
const int INF9 = 2 * 1e9;
const long long INF18 = 4 * 1e18;
const long long L0 = 0;
const long double PI = acos(-1);
const long double sq2 = sqrt(2.0);
int main() {
int n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < (n); i++) cin >> v[i];
if (n == 1) {
cout << "1 1" << endl << "0" << endl;
cout << "1 1" << endl << "0" << endl;
cout << "1 1" << endl << -v[0] << endl;
return 0;
}
map<long long, long long> m;
long long x = n - 1;
while (m.find(x % n) == m.end()) {
m[x % n] = x;
x += n - 1;
}
cout << 1 << ' ' << n - 1 << endl;
for (long long i = 0; i < (n - 1); i++) {
long long d = m[(n - (v[i] % n)) % n];
cout << d << ' ';
v[i] += d;
}
cout << endl << n << ' ' << n << endl;
cout << n - v[n - 1] << endl;
v[n - 1] = n;
cout << 1 << ' ' << n << endl;
for (long long i = 0; i < (n); i++) cout << -v[i] << ' ';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int x = 0, y = 0, pos = 0, ans = 0;
if (s[0] == 'R') {
pos = 1;
}
for (int i = 0; i < s.length();) {
if (s[i] == 'R') {
while (s[i] == 'R') {
x++;
i++;
}
} else if (s[i] == 'U') {
while (s[i] == 'U') {
y++;
i++;
}
}
if (i > 0) {
if (pos == 0 && x > y) {
ans++;
pos++;
} else if (pos == 1 && y > x) {
ans++;
pos--;
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
vector<int> g[maxn];
int d[maxn];
pair<int, int> e[maxn * 2];
int main() {
int n, m, h, t;
scanf("%d%d%d%d", &n, &m, &h, &t);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
e[i] = {u, v};
e[i + m] = {v, u};
d[u]++;
d[v]++;
}
for (int i = m * 2 - 1; i >= 0; --i) {
int u = e[i].first;
int v = e[i].second;
if (d[u] - 1 < h || d[v] - 1 < t) {
continue;
} else if (d[u] - 1 >= t + h || d[v] - 1 >= t + h) {
printf("YES\n");
printf("%d %d\n", u, v);
unordered_set<int> s1, s2;
for (auto w : g[u]) {
if (w != v) {
s1.insert(w);
}
}
for (auto w : g[v]) {
if (w != u) {
s2.insert(w);
}
}
unordered_set<int> st;
for (auto w : s1) {
if (s2.find(w) != s2.end()) {
st.insert(w);
}
}
for (auto w : st) {
s1.erase(w);
s2.erase(w);
}
for (auto w : s1) {
printf("%d ", w);
h--;
if (h == 0) {
break;
}
}
while (h--) {
printf("%d ", *st.begin());
st.erase(st.begin());
}
printf("\n");
for (auto w : s2) {
printf("%d ", w);
t--;
if (t == 0) {
break;
}
}
while (t--) {
printf("%d ", *st.begin());
st.erase(st.begin());
}
printf("\n");
return 0;
} else {
unordered_set<int> s1, s2;
for (auto w : g[u]) {
if (w != v) {
s1.insert(w);
}
}
for (auto w : g[v]) {
if (w != u) {
s2.insert(w);
}
}
unordered_set<int> st;
for (auto w : s1) {
if (s2.find(w) != s2.end()) {
st.insert(w);
}
}
for (auto w : st) {
s1.erase(w);
s2.erase(w);
}
int a = st.size();
int x = s1.size();
int y = s2.size();
if (x + y + a >= t + h) {
printf("YES\n");
printf("%d %d\n", u, v);
for (auto w : s1) {
printf("%d ", w);
h--;
if (h == 0) {
break;
}
}
while (h--) {
printf("%d ", *st.begin());
st.erase(st.begin());
}
printf("\n");
for (auto w : s2) {
printf("%d ", w);
t--;
if (t == 0) {
break;
}
}
while (t--) {
printf("%d ", *st.begin());
st.erase(st.begin());
}
printf("\n");
return 0;
}
}
}
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string dToB(int n) {
string s = bitset<64>(n).to_string();
const auto loc1 = s.find('1');
if (loc1 != string::npos) return s.substr(loc1);
return "0";
}
int main() {
int t;
cin >> t;
string s = dToB(t);
while (s.length() != 6) s = '0' + s;
string ans = "000000";
ans[0] = s[0];
ans[1] = s[5];
ans[2] = s[3];
ans[3] = s[2];
ans[4] = s[4];
ans[5] = s[1];
cout << stoi(ans, 0, 2) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, na, d[32 + 1];
void nhap() { cin >> n >> k; }
int dem() {
int i, kq;
kq = 0;
for (i = 0; i <= na; i = i + 1) {
kq = kq + d[i];
};
return (kq);
}
int tang() {
int i;
for (i = 1; i <= na; i = i + 1) {
if (d[i] >= 1) {
d[i] = d[i] - 1;
d[i - 1] = d[i - 1] + 2;
break;
}
}
}
void xu_ly() {
int nd;
nd = n;
na = -1;
while (n != 0) {
na = na + 1;
int sd;
sd = n % 2;
if (sd == 1) {
d[na] = 1;
} else {
d[na] = 0;
};
n = n / 2;
}
if (dem() > k) {
cout << "NO";
return;
}
while (dem() < k && d[0] < nd) {
tang();
};
if (dem() < k) {
cout << "NO";
return;
}
cout << "YES" << endl;
int i;
for (i = 0; i <= na; i = i + 1) {
if (d[i] >= 1) {
int kq;
kq = pow(2, i);
int j;
for (j = 1; j <= d[i]; j = j + 1) {
cout << kq << " ";
};
}
}
}
int main() {
nhap();
xu_ly();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char h[1000002];
scanf("%s", h);
string x = string(h);
int i;
for (i = 0; i < x.size(); i++)
if (x[i] != '0') break;
if (i) x.erase(x.begin(), x.begin() + i);
for (i = 0; i < x.size(); i++)
if (x[i] == '.') break;
if (i == x.size()) x += ".";
for (i = x.size() - 1; i >= 0; i--)
if (x[i] == '0')
x.erase(x.begin() + i);
else
break;
for (i = 0; i < x.size(); i++)
if (x[i] == '.') break;
if (i == 1) {
if (x.size() == 2)
cout << x[0] << endl;
else
cout << x << endl;
} else if (!i) {
string ans = "";
int k = 0;
for (int i = 1, b = 0; i < x.size(); i++)
if (b)
ans += x[i];
else if (x[i] != '0')
ans += x[i], ans += ".", b = 1, k = i;
if (ans.size() == 2)
cout << ans[0] << "E" << -k << endl;
else
cout << ans << "E" << -k << endl;
} else {
int k = 0;
if (x[x.size() - 1] == '.') {
k = x.size() - 2;
for (i = x.size() - 2; i >= 0; i--)
if (x[i] == '0')
x.erase(x.begin() + i);
else
break;
}
string ans = "";
ans += x[0];
ans += ".";
for (int i = 1, b = 0; i < x.size(); i++)
if (x[i] == '.')
if (!k)
k = i - 1;
else
break;
else
ans += x[i];
if (ans.size() == 2)
cout << ans[0] << "E" << k << endl;
else
cout << ans << "E" << k << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s2 = "I hate ";
string l = "that I hate ";
string g = "that I love ";
string gf = "it";
string s1 = "that I love ";
string s3 = "that I love that I hate ";
cin >> n;
cout << s2;
if (n == 2)
cout << s1;
else if (n == 3)
cout << s3;
else if (n != 1) {
for (int i = 2; i <= n; i++) {
if (i % 2 == 0)
cout << g;
else
cout << l;
}
}
cout << gf;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool v = false, h = false;
for (auto &x : s) {
if (x == '0') {
if (v) {
cout << "3 4" << endl;
} else {
cout << "1 4" << endl;
}
v = !v;
} else {
if (h) {
cout << "4 3" << endl;
} else {
cout << "4 1" << endl;
}
h = !h;
}
}
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int n , s;
int dfs(int i , int sum , int N){
if(N == 0 && sum == 0) return 1;//yes
if(N == 0 || i == 10) return 0;//no
return dfs(i + 1 , sum , N) + dfs(i + 1 , sum - i , N - 1);
}
int main(){
while(cin >> n >> s , n){
cout << dfs(0 , s , n) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m = 40;
cin >> n;
int v[n];
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] < m) m = v[i];
}
cout << 2 + (v[2] ^ m) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define for_(i,a,b) for(int i=a;i<b;++i)
int N, tt[22][22], use[22];
int dfs(int v, int p, int ct) {
int res = ct;
for_(i,0,N) {
if (i == p || tt[v][i] == -1 || !use[i]) continue;
res = max(res, dfs(i, v, ct + tt[v][i]));
}
return res;
}
int main() {
while (cin >> N, N) {
memset(tt, -1, sizeof(tt));
for_(i,0,N-1) {
int a, b, t; cin >> a >> b >> t;
--a; --b;
tt[a][b] = tt[b][a] = t;
}
memset(use, 0, sizeof(use));
for_(i,0,N) {
int cnt = 0;
for_(j,0,N) if (tt[i][j] != -1) ++cnt;
if (cnt > 1) use[i] = 1;
}
use[0] = 1;
int ans = 0;
for_(i,0,N) for_(j,i+1,N) if (use[i] && use[j] && tt[i][j] > 0) ans += tt[i][j];
cout << 2 * ans - dfs(0, -1, 0) << endl;
}
return 0;
} | 0 |
#include <iostream>
#define W 0
#define B 1
using namespace std;
int n;
int m;
int p;
int cou;
int dy[]={0, -1, -1, -1, 0, -1, -1, -1, 0, -1, -1, -1, 0};
int dx[]={1, 1, 0, -1, 1, 1, 0, -1, 1, 1, 0, -1, 0};
int dz[]={0, 0, 0, 0, 1, 1, 1, 1, -1, -1, -1, -1, 1};
int hantei(int, int, int, int);
class peg{
public:
int ball[400];
};
peg data[7][7];
int main(){
while(1){
cin >> n >> m >> p;
if(n==0 && m==0 && p==0) break;
for(int a=0;a<n;a++){
for(int b=0;b<n;b++){
for(int c=0;c<=p;c++){
data[a][b].ball[c]=-1;
}
}
}
int ans=0;
int win=-1;
bool end=false;
for(cou=0;cou<p;cou++){
int x, y;
cin >> x >> y;
if(end) continue;
x--;
y--;
if(cou%2==0){
for(int j=0;;j++){
if(data[y][x].ball[j]==-1){
int tmp;
data[y][x].ball[j]=B;
//printf("%d %d %d %d\n", x, y, j, B);
tmp=hantei(x, y, j, B);
//printf("%d\n", tmp);
if(tmp>=m){
win=B;
ans=cou+1;
}
break;
}
}
}
else{
for(int j=0;;j++){
if(data[y][x].ball[j]==-1){
int tmp;
data[y][x].ball[j]=W;
//printf("%d %d %d %d\n", x, y, j, W);
tmp=hantei(x, y, j, W);
//printf("!%d\n", tmp);
if(tmp>=m){
win=W;
ans=cou+1;
}
break;
}
}
}
if(win!=-1) end=true;
}
if(win==W){
printf("White %d\n", ans);
}
else if(win==B){
printf("Black %d\n", ans);
}
else{
printf("Draw\n");
}
}
return 0;
}
int hantei(int x, int y, int z, int col){
int max=-1;
for(int i=0;i<13;i++){
int tx=x, ty=y, tz=z;
int count=0;
while(1){
if((tx<0 || tx>=n) || (ty<0 || ty>=n) || tz<0) break;
if(data[ty][tx].ball[tz]!=col) break;
count++;
tx+=dx[i];
ty+=dy[i];
tz+=dz[i];
}
//printf("@%d ", count);
tx=x-dx[i];
ty=y-dy[i];
tz=z-dz[i];
while(1){
if((tx<0 || tx>=n) || (ty<0 || ty>=n) || tz<0) break;
if(data[ty][tx].ball[tz]!=col) break;
count++;
tx+=-1*dx[i];
ty+=-1*dy[i];
tz+=-1*dz[i];
}
//printf("%d\n", count);
if(max<count) max=count;
}
return max;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long hxtype;
template<class IT>inline void cmax(IT &a,IT b){if(a<b)a=b;}
template<class IT>inline void cmin(IT &a,IT b){if(b<a)a=b;}
const int N=100001;
int a[N],c[N];
inline bool cmp(int a,int b){return a>b;}
int main(){
int n,m,v,p,i,l,r,d,s,t;ll T;
scanf("%d%d%d%d",&n,&m,&v,&p);
v=n-v;l=(s=p)+1;r=n;
for(i=1;i<=n;++i)scanf("%d",&a[i]);
sort(a+1,a+n+1,cmp);
while(l<=r){
d=(l+r)>>1;t=v;T=0ll;
for(i=p;i!=d;++i){
if(t){--t;T-=m;}
T+=a[i]-a[d];
if(T>0ll)break;
}
// printf("d=%d i=%d\n",d,i);
if(i==d)l=(s=d)+1;else r=d-1;
}
printf("%d",s);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 405, M = 1e9 + 7;
int dp[N][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
dp[1][0] = 1;
dp[1][1] = 1;
for (int i = 2; i <= n; i++) {
dp[i][0] = 1;
for (int k = 1; k <= n; k++) {
for (int j = 0; j <= k; j++) {
int ways = (1LL * dp[i - 1][j] * dp[i - 1][k - j]) % M;
dp[i][k] = (dp[i][k] + ways) % M;
dp[i][k] = (dp[i][k] + (2LL * ways * k)) % M;
}
for (int j = 0; j <= k - 1; j++) {
dp[i][k] = (dp[i][k] + 1LL * dp[i - 1][j] * dp[i - 1][k - 1 - j]) % M;
}
for (int j = 0; j <= k + 1; j++) {
int ways = (1LL * dp[i - 1][j] * dp[i - 1][k + 1 - j]) % M;
int pr = (k * (k + 1)) % M;
dp[i][k] = (dp[i][k] + 1LL * pr * ways) % M;
}
}
}
cout << dp[n][1] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
string a;
int f[1005][5];
int main() {
cin >> n >> a;
string t = "", s = "";
char cur = '0';
for (int i = 0; i <= n - 1; i++) {
t += cur;
s += '1' - cur + '0';
cur = '1' - cur + '0';
}
int ans = (int)2e9;
int res = 0, res1 = 0;
for (int i = 0; i <= n - 1; i++) {
if (a[i] != s[i]) res++;
if (a[i] != t[i]) res1++;
}
ans = min(res1, res);
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x20202020;
const int mod = 1000000007;
template <class T>
inline void read(T &x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T &x, T &y) {
read(x);
read(y);
}
template <class T>
inline void read(T &x, T &y, T &z) {
read(x);
read(y);
read(z);
}
template <class T>
inline void read(T &x, T &y, T &z, T &q) {
read(x);
read(y);
read(z);
read(q);
}
const int DX[] = {1, 0, -1, 0, -1, -1, 1, 1, 0},
DY[] = {0, 1, 0, -1, -1, 1, -1, 1, 0};
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 18999999, M = 3333;
int l, m, n, t, C, f[N], x, y, vis[M][2 * M], nn;
inline int cal(const int &x) {
if (x >= n) return x - n;
if (x < 0) return x + n;
return x;
}
int getf(int x) {
if (x == f[x]) return x;
return f[x] = getf(f[x]);
}
void modi(int x, int y) {
for (int _tmp = 7, k = 0; k <= _tmp; ++k)
if (vis[x + DX[k]][cal(y + DY[k] - 1)])
f[getf(((x + DX[k]) * (n + 2) + cal(y + DY[k] - 1)))] =
getf(((x) * (n + 2) + cal(y - 1)));
vis[x][cal(y - 1)] = 1;
}
set<int> S;
int main() {
read(m, n, C);
nn = n;
n *= 2;
if (nn == 1) {
puts("0");
return 0;
}
for (int _tmp = m + 1, i = 0; i <= _tmp; ++i)
for (int _tmp = n + 1, j = 0; j <= _tmp; ++j)
f[((i) * (n + 2) + cal(j - 1))] = ((i) * (n + 2) + cal(j - 1));
int ans = 0;
for (int _tmp = C, _ = 1; _ <= _tmp; ++_) {
read(x, y);
int bo2 = 0;
int tmp1[9], tmp2[9], t1 = 0, t2 = 0;
for (int _tmp = 7, u = 0; u <= _tmp; ++u)
if (vis[x + DX[u]][cal(y + DY[u] - 1)])
tmp1[++t1] = getf(((x + DX[u]) * (n + 2) + cal(y + DY[u] - 1)));
for (int _tmp = 7, v = 0; v <= _tmp; ++v)
if (vis[x + DX[v]][cal(y + DY[v] + nn - 1)])
tmp2[++t2] = getf(((x + DX[v]) * (n + 2) + cal(y + DY[v] + nn - 1)));
S.clear();
for (int _tmp = t1, i = 1; i <= _tmp; ++i) S.insert(tmp1[i]);
for (int _tmp = t2, i = 1; i <= _tmp; ++i)
if (S.find(tmp2[i]) != S.end()) {
bo2 = 1;
break;
}
if (bo2) continue;
modi(x, y);
modi(x, y + nn);
++ans;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int mod = 998244353;
struct node {
int sum, tot;
node(){};
node(int S, int T) {
sum = S;
tot = T;
}
bool check() { return ~sum && ~tot; }
} f[2][2][N][1 << 10];
int A[N], ret, pw[30], k;
int lowbit(int x) { return x & -x; }
int ccount(int x) {
int cnt = 0;
if (!x) return 0;
while (x) {
x ^= lowbit(x);
cnt++;
}
return cnt;
}
node dfs(bool lim, bool zero, int pos, int st) {
if (!pos) return node(0, 1);
node& now = f[lim][zero][pos][st];
if (now.check()) return now;
now.sum = now.tot = 0;
for (int i = 0; i <= (lim ? A[pos] : 9); i++) {
if (ccount(zero && !i ? 0 : st | (1 << i)) <= k) {
node nxt = dfs(lim && i == A[pos], zero && !i, pos - 1,
zero && !i ? 0 : st | (1 << i));
now.sum =
(now.sum + nxt.sum + 1ll * i * nxt.tot % mod * pw[pos - 1] % mod) %
mod;
now.tot = (now.tot + nxt.tot) % mod;
}
}
f[lim][zero][pos][st] = now;
return now;
}
int calc(long long x) {
ret = 0;
memset(f, -1, sizeof(f));
while (x) {
A[++ret] = x % 10;
x /= 10;
}
return dfs(1, 1, ret, 0).sum;
}
int main() {
pw[0] = 1;
for (int i = 1; i <= 20; i++) pw[i] = 10ll * pw[i - 1] % mod;
long long l, r;
cin >> l >> r >> k;
cout << (mod + calc(r) - calc(l - 1)) % mod;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int m, n;
int sen[200000];
int change[200];
int x, y;
int a, b;
int c;
scanf("%d %d", &n, &m);
getchar();
for (a = 0; a <= 199; a++) {
change[a] = a;
}
for (a = 0; a <= n - 1; a++) {
c = getchar();
sen[a] = c;
}
getchar();
for (a = 0; a <= m - 1; a++) {
x = getchar();
getchar();
y = getchar();
getchar();
for (b = 97; b <= 122; b++) {
if (change[b] == x)
change[b] = y;
else if (change[b] == y)
change[b] = x;
}
}
for (b = 0; b <= n - 1; b++) {
sen[b] = change[sen[b]];
}
for (a = 0; a <= n - 1; a++) {
printf("%c", sen[a]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2e6 + 20, mod = 1e9 + 7;
long long p, root[N], k, ans = 1;
int find(int v) { return root[v] < 0 ? v : root[v] = find(root[v]); }
void merge(int v, int u) {
if ((u = find(u)) == (v = find(v))) return;
if (root[u] < root[v]) swap(u, v);
root[v] += root[u];
root[u] = v;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> p >> k;
fill(root, root + p, -1);
if (!k) {
for (int i = 1; i < p; i++) (ans *= p) %= mod;
return cout << ans, 0;
}
for (int i = 1; i < p; i++) {
merge(i, k * i % p);
}
for (int i = 1; i < p; i++) {
if (find(i) == i) (ans *= p) %= mod;
}
int cnt = 0;
for (int i = 0; i < p; i++) {
cnt += (k * i % p == i);
}
(ans *= cnt) %= mod;
return cout << ans, 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 10;
const long long inf = -(1LL << 60);
const long long MOD = 998244353;
int n, m;
int in[N << 2][2];
long long tree[N << 2][2];
long long d[N], h[N], sum[N];
void pushup(int o) {
if (tree[2 * o][0] >= tree[2 * o + 1][0]) {
tree[o][0] = tree[2 * o][0];
in[o][0] = in[2 * o][0];
} else {
tree[o][0] = tree[2 * o + 1][0];
in[o][0] = in[2 * o + 1][0];
}
if (tree[2 * o][1] >= tree[2 * o + 1][1]) {
tree[o][1] = tree[2 * o][1];
in[o][1] = in[2 * o][1];
} else {
tree[o][1] = tree[2 * o + 1][1];
in[o][1] = in[2 * o + 1][1];
}
}
void build(int o, int L, int R) {
if (L == R) {
in[o][0] = in[o][1] = L;
tree[o][0] = 2 * h[L] - sum[L - 1];
tree[o][1] = 2 * h[L] + sum[L - 1];
return;
}
int mid = L + (R - L) / 2;
build(2 * o, L, mid);
build(2 * o + 1, mid + 1, R);
pushup(o);
}
int query(int o, int L, int R, int x, int y, int index) {
int ans1 = -1, ans2 = -1;
if (x <= L && R <= y) return in[o][index];
int mid = L + (R - L) / 2;
if (x <= mid) ans1 = query(2 * o, L, mid, x, y, index);
if (mid < y) ans2 = query(2 * o + 1, mid + 1, R, x, y, index);
if (ans1 == -1) return ans2;
if (ans2 == -1) return ans1;
if (index == 0) {
if (2 * h[ans1] - sum[ans1 - 1] >= 2 * h[ans2] - sum[ans2 - 1])
return ans1;
else
return ans2;
} else {
if (2 * h[ans1] + sum[ans1 - 1] >= 2 * h[ans2] + sum[ans2 - 1])
return ans1;
else
return ans2;
}
}
long long getans(int x, int y, int f) {
long long ans;
int in1, in2 = -1, in3 = -1;
in1 = query(1, 1, 2 * n, x, y, f);
if (in1 - 1 >= x) in2 = query(1, 1, 2 * n, x, in1 - 1, f ^ 1);
if (y >= in1 + 1) in3 = query(1, 1, 2 * n, in1 + 1, y, f ^ 1);
if (f == 0) {
if (in2 != -1 && in3 != -1)
ans = max(2 * h[in2] + sum[in2 - 1], 2 * h[in3] + sum[in3 - 1]);
else if (in2 != -1)
ans = 2 * h[in2] + sum[in2 - 1];
else if (in3 != -1)
ans = 2 * h[in3] + sum[in3 - 1];
return ans + 2 * h[in1] - sum[in1 - 1];
} else {
if (in2 != -1 && in3 != -1)
ans = max(2 * h[in2] - sum[in2 - 1], 2 * h[in3] - sum[in3 - 1]);
else if (in2 != -1)
ans = 2 * h[in2] - sum[in2 - 1];
else if (in3 != -1)
ans = 2 * h[in3] - sum[in3 - 1];
return ans + 2 * h[in1] + sum[in1 - 1];
}
}
int main() {
sum[0] = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
cin >> d[i];
d[i + n] = d[i];
}
for (int i = 1; i <= 2 * n; i++) sum[i] = sum[i - 1] + d[i];
for (int i = 1; i <= n; i++) {
cin >> h[i];
h[i + n] = h[i];
}
build(1, 1, 2 * n);
while (m--) {
int a, b, x, y;
scanf("%d%d", &a, &b);
if (a <= b) {
x = b + 1;
y = a + n - 1;
}
if (a > b) {
x = b + 1;
y = a - 1;
}
long long ans1 = getans(x, y, 0);
long long ans2 = getans(x, y, 1);
cout << max(ans1, ans2) << endl;
}
}
| 5 |
#include "bits/stdc++.h"
using namespace std;
int INF = 1e8;
int f(vector < pair<int, int> >vec) {
sort(vec.begin(),vec.end());
int res = INF;
for (int i = 1;i<vec.size();++i) {
if (0 == vec[i-1].second && 0 != vec[i].second) {
res = min(res,vec[i].first- vec[i-1].first);
}
}
return res;
}
int f(map<int, vector<pair<int, int>>>mp) {
int res = INF;
for (auto p:mp) {
res = min(res,f(p.second));
}
return res;
}
int main() {
int N;
cin >> N;
vector<int>X(N), Y(N), U(N);
for (int n = 0;n<N;++n) {
char c;
cin >> X[n]>> Y[n]>>c;
if ('U' == c) {
U[n] = 0;
}
if ('R' == c) {
U[n] = 1;
}
if ('D' == c) {
U[n] = 2;
}
if ('L' == c) {
U[n] = 3;
}
}
int ans = INF;
for (int n = 0;n < 4;++n) {
//正面衝突
{
map<int, vector<pair<int, int>>>mp;
for (int m = 0; m < N; ++m) {
if (0 != U[m] &&2 != U[m]) {
continue;
}
mp[X[m]].emplace_back(Y[m],U[m]);
}
ans = min(ans,f(mp)*5);
}
//垂直衝突
{
map<int, vector<pair<int, int>>>mp;
for (int m = 0; m < N; ++m) {
if (0 != U[m] && 1 != U[m]) {
continue;
}
mp[X[m]+Y[m]].emplace_back(Y[m], U[m]);
}
ans = min(ans, f(mp) * 10);
}
//回転
{
for (int m = 0; m < N; ++m) {
int px = X[m];
int py = Y[m];
X[m] = py;
Y[m] = -px;
U[m] = (U[m] + 1) % 4;
}
}
}
if (INF == ans) {
cout << "SAFE"<<endl;
}
else {
cout << ans << endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
using namespace std;
int main(){
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
printf("%d", n ^ m ^ p);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int vis[1010];
int minn = 1100;
int main() {
int n, m, x;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d", &x);
vis[x]++;
}
for (int i = 1; i <= n; i++) minn = min(minn, vis[i]);
printf("%d\n", minn);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define MAX_N 100000
struct edge{ int to,cost; };
typedef pair<int,int> P;
const int INF=1000000001;
int N,M;
int d[MAX_N];
vector<edge> G[MAX_N];
int main(){
cin>>N>>M;
for(int i=0;i<M;i++){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
G[a].push_back((edge){b,c});
}
int ans=-1;
priority_queue< P , vector<P> , greater<P> > Q;
fill(d,d+MAX_N,INF);
Q.push(P(1,1));
d[1]=1;
while(!Q.empty()){
P p=Q.top();Q.pop();
int pos=p.second;
int cost=p.first;
if(d[pos]<cost)continue;
for(int i=0;i<(int)G[pos].size();i++){
edge e=G[pos][i];
if(e.cost<d[pos])continue;
if(e.to==N)ans=max(ans,e.cost);
if(d[e.to]>e.cost){
d[e.to]=e.cost;
Q.push(P(d[e.to],e.to));
}
}
}
printf("%d\n",ans);
return 0;
} | 0 |
#ifdef LOCAL
#pragma GCC optimize ("O0")
#else
#pragma GCC optimize ("O3")
#endif
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1e9 + 7;
const int MOD = INF;
const ll INF_LL = 1e18 + 7;
#define __overload3(_1, _2, _3, name,...) name
#define rep(...) __overload3(__VA_ARGS__, repFromUntil, repUntil, repeat)(__VA_ARGS__)
#define repeat(times) repFromUntil(__name, 0, times)
#define repUntil(name, times) repFromUntil(name, 0, times)
#define repFromUntil(name, from, until) for (int name = from, name##__until = (until); name < name##__until; name++)
#define repFromTo(name, from, to) repFromUntil(name, from, to + 1)
#define repr(...) __overload3(__VA_ARGS__, reprFromUntil, reprUntil, repeat)(__VA_ARGS__)
#define reprUntil(name, times) reprFromUntil(name, 0, times)
#define reprFromUntil(name, from, until) for (int name = until - 1, name##__from = (from); name >= name##__from; name--)
#define reprFromTo(name, from, to) reprFromUntil(name, from, to + 1)
#define debugos OUT
#ifdef LOCAL
#define debug(v) {printf("L%d %s > ",__LINE__,#v);debugos<<(v)<<newl;}
#define debugv(v) {printf("L%d %s > ",__LINE__,#v);for(auto e:(v)){debugos<<e<<" ";}debugos<<newl;}
#define debuga(m,w) {printf("L%d %s > ",__LINE__,#m);for(int x=0;x<(w);x++){debugos<<(m)[x]<<" ";}debugos<<newl;}
#define debugaa(m,h,w) {printf("L%d %s >\n",__LINE__,#m);for(int y=0;y<(h);y++){for(int x=0;x<(w);x++){debugos<<(m)[y][x]<<" ";}debugos<<newl;}}
#else
#define debug(v) {}
#define debugv(v) {}
#define debuga(m,w) {}
#define debugaa(m,h,w) {}
#endif
#define newl "\n"
#define all(iter) begin(iter), end(iter)
template <class T> bool chmin(T& var, T x) {
if (var > x) {
var = x;
return true;
} else return false;
}
template <class T> bool chmax(T& var, T x) {
if (var < x) {
var = x;
return true;
} else return false;
}
class MyScanner {
public:
template<typename T> void input_integer(T& var) {
var = 0; T sign = 1;
int cc = getchar();
for (; cc<'0' || '9'<cc; cc = getchar())
if (cc == '-') sign = -1;
for (; '0' <= cc && cc <= '9'; cc = getchar())
var = (var << 3) + (var << 1) + cc - '0';
var = var * sign;
}
int c() { char c; while (c = getchar(), c == ' ' or c == '\n'); return c; }
MyScanner& operator>>(char& var) { var = c(); return *this; }
MyScanner& operator>>(int& var) { input_integer<int>(var); return *this; }
MyScanner& operator>>(ll& var) { input_integer<ll>(var); return *this; }
MyScanner& operator>>(string& var) {
int cc = getchar();
for (; !isvisiblechar(cc); cc = getchar());
for (; isvisiblechar(cc); cc = getchar())
var.push_back(cc);
return *this;
}
operator int() {
int n;
*this >> n;
return n;
}
operator ll() {
ll n;
*this >> n;
return n;
}
private:
int isvisiblechar(int c) {
return 0x21 <= c && c <= 0x7E;
}
};
class MyPrinter {
public:
template<typename T>
void output_integer(T var) {
if (var == 0) { putchar('0'); return; }
if (var < 0)
putchar('-'),
var = -var;
char stack[32]; int stack_p = 0;
while (var)
stack[stack_p++] = '0' + (var % 10),
var /= 10;
while (stack_p)
putchar(stack[--stack_p]);
}
MyPrinter& operator<<(char c) { putchar(c); return *this; }
template <typename T>
MyPrinter& operator<<(T var) { output_integer<T>(var); return *this; }
MyPrinter& operator<<(char* str_p) { while (*str_p) putchar(*(str_p++)); return *this; }
MyPrinter& operator<<(const char* str_p) { while (*str_p) putchar(*(str_p++)); return *this; }
MyPrinter& operator<<(const string& str) {
const char* p = str.c_str();
const char* l = p + str.size();
while (p < l) putchar(*p++);
return *this;
}
// MyPrinter& operator<<(const modint& var) { output_integer<ll>(var.value); return *this; }
template <typename T>
void operator()(T x) {
*this << x << newl;
}
};
MyScanner IN;
MyPrinter OUT;
template <typename Iter>
void dump(Iter s, Iter t) {
if (s == t) OUT << "\n";
else {
for (; s != t; s++) {
OUT << *s << " \n"[next(s, 1) == t];
}
}
}
int main() {
int n, m;
IN >> n;
vector<int> a(n);
rep(i, n) IN >> a[i];
IN >> m;
vector<int> b(m);
rep(i, m) IN >> b[i];
OUT(b > a ? 1 : 0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b) {
long long res = 1;
a %= 1000000007;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res % 1000000007;
}
int main() {
int u, v;
cin >> u >> v;
int t, d;
cin >> t >> d;
int fo[t], bk[t];
fo[0] = u;
bk[t - 1] = v;
for (int i = 1; i < t; i++) {
fo[i] = fo[i - 1] + d;
}
for (int i = t - 2; i >= 0; i--) {
bk[i] = bk[i + 1] + d;
}
int sum = 0;
for (int i = 0; i < t; i++) {
sum += min(fo[i], bk[i]);
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long g = n - 1, res = 0;
while (g > 0 && k > 0) {
res += g * 2 - 1;
k--;
g -= 2;
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string ConverToRomanNumber(int n, int index) {
int m;
const char *roman_number = "IVXLCDMRP";
string ret("");
if (n / 10) ret = ConverToRomanNumber(n / 10, index + 2);
n %= 10;
while (n < 4 && n--) ret.append(string(1, roman_number[index - 1]));
ret.append(n == 4 ? string(1, roman_number[index - 1]) +
string(1, roman_number[index])
: "");
ret.append(n >= 5 && n < 9 ? string(1, roman_number[index]) : "");
ret.append(n == 9 ? string(1, roman_number[index - 1]) +
string(1, roman_number[index + 1])
: "");
while (n < 9 && n-- > 5) ret.append(string(1, roman_number[index - 1]));
return (ret);
}
static int declen_base(long long n, int base) {
int len;
len = 1;
while ((n = n / base)) len++;
return (len);
}
char *itoa_base(long long n, int base) {
const char *b;
int len;
char *res;
bool sign;
b = "0123456789ABCDEFGHIJKLMNOPARSTUVWXYZ";
sign = n < 0 && base == 10 ? 1 : 0;
len = declen_base(n, base);
res = (char *)malloc(len + sign + 1);
res[len + sign] = 0;
if (!res) return (NULL);
res[0] = '-';
while (len--) {
res[len + sign] = b[abs(n % base)];
n /= base;
}
return (res);
}
int main() {
long long a, n;
string c, b;
cin >> a >> b >> c;
n = stoll(c, 0, a);
cout << (b[0] == 'R' ? ConverToRomanNumber(n, 1)
: itoa_base(n, atoi(b.data())));
}
| 3 |
#include <bits/stdc++.h>
const int MN = 1e6 + 44;
int cou[MN];
int arr[MN];
int divcou[MN];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", arr + i);
if (arr[i] <= m) cou[arr[i]]++;
}
for (int i = 1; i < MN; ++i)
for (int k = i; k < MN; k += i) divcou[k] += cou[i];
int M = 0, wh = 1;
for (int i = 1; i <= m; ++i)
if (divcou[i] > M) {
M = divcou[i];
wh = i;
}
printf("%d %d\n", wh, M);
for (int i = 0; i < n; ++i)
if (wh % arr[i] == 0) printf("%d ", i + 1);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int l[200], r[200];
int main() {
int p1, p2, p3, t1, t2, n;
cin >> n >> p1 >> p2 >> p3 >> t1 >> t2;
int ans = 0;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
r[0] = l[i];
ans += (r[i] - l[i]) * p1;
int ll = l[i] - r[i - 1];
ans += min(ll, t1) * p1;
ll -= min(ll, t1);
ans += min(ll, t2) * p2;
ll -= min(ll, t2);
ans += ll * p3;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long N, M;
const long long INF = numeric_limits<long long>::max();
struct Edge {
long long u, v, c;
Edge() {}
Edge(long long u, long long v, long long c) : u(u), v(v), c(c) {}
};
vector<vector<long long>> G(20010LL);
vector<long long> match(20010LL), dist(20010LL);
long long n, m;
bool bfs() {
long long i, u, v, len;
queue<long long> Q;
for (i = 1; i <= n; i++) {
if (match[i] == 0LL) {
dist[i] = 0;
Q.push(i);
} else
dist[i] = INF;
}
dist[0LL] = INF;
while (!Q.empty()) {
u = Q.front();
Q.pop();
if (u != 0LL) {
len = G[u].size();
for (i = 0; i < len; i++) {
v = G[u][i];
if (dist[match[v]] == INF) {
dist[match[v]] = dist[u] + 1LL;
Q.push(match[v]);
}
}
}
}
return (dist[0LL] != INF);
}
bool dfs(long long u) {
long long i, v, len;
if (u != 0LL) {
len = G[u].size();
for (i = 0; i < len; i++) {
v = G[u][i];
if (dist[match[v]] == dist[u] + 1LL) {
if (dfs(match[v])) {
match[v] = u;
match[u] = v;
return true;
}
}
}
dist[u] = INF;
return false;
}
return true;
}
long long hopcroft_karp() {
long long matching = 0LL, i;
while (bfs())
for (i = 1; i <= n; i++)
if (match[i] == 0LL && dfs(i)) matching++;
return matching;
}
vector<Edge> edges;
bool factible(long long m) {
G.assign(N + 1, {});
for (Edge &e : edges) {
if (e.c <= m) {
G[e.u].push_back(e.v + n);
G[e.v + n].push_back(e.u);
}
}
fill(match.begin(), match.end(), 0LL);
fill(dist.begin(), dist.end(), 0LL);
return (hopcroft_karp() == N);
}
long long bs() {
long long lb = 0LL;
long long ub = INF - 10LL;
long long m;
while (lb != ub) {
m = (ub - lb) / 2LL + lb;
if (factible(m))
ub = m;
else
lb = m;
if ((ub == lb + 1LL) || (ub < lb)) break;
}
long long res = INF - 10LL;
if (factible(lb - 1LL)) res = min(res, lb - 1LL);
if (factible(lb)) res = min(res, lb);
if (factible(lb + 1LL)) res = min(res, lb + 1LL);
if (factible(ub - 1LL)) res = min(res, ub - 1LL);
if (factible(ub)) res = min(res, ub);
if (factible(ub + 1LL)) res = min(res, ub + 1LL);
if (factible(m - 1LL)) res = min(res, m - 1LL);
if (factible(m)) res = min(res, m);
if (factible(m + 1LL)) res = min(res, m + 1LL);
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> M;
n = N, m = N;
edges.resize(M);
for (long long i = 0; i < M; i++) {
cin >> edges[i].u >> edges[i].v >> edges[i].c;
}
long long res = bs();
if (res > 1000000010LL) {
cout << -1 << endl;
} else
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[300000], dp2[300000];
long long pos[300000], pos2[300000];
long long a[300000];
int main() {
long long n, k;
cin >> n >> k;
memset(dp, 0, sizeof(dp));
memset(dp2, 0, sizeof(dp2));
a[0] = 0;
long long val;
for (long long i = 1; i <= n; i++) {
cin >> val;
a[i] = a[i - 1] + val;
}
dp[0] = 0;
dp[k] = a[k];
pos[k] = 1;
for (long long i = 1; i <= n; i++) {
if (i <= k) {
continue;
}
dp[i] = dp[i - 1];
pos[i] = pos[i - 1];
if (a[i] - a[i - k] > dp[i]) {
dp[i] = a[i] - a[i - k];
pos[i] = i - k + 1;
}
}
dp2[n + 1] = 0;
dp2[n - k + 1] = a[n] - a[n - k];
pos2[n - k + 1] = n - k + 1;
for (long long j = n; j >= 1; j--) {
if (j > n - k) {
continue;
} else {
dp2[j] = dp2[j + 1];
pos2[j] = pos2[j + 1];
if (a[j + k - 1] - a[j - 1] >= dp2[j]) {
dp2[j] = a[j + k - 1] - a[j - 1];
pos2[j] = j;
}
}
}
long long maxval = 0;
long long posi, posj;
for (long long i = k; i <= n - k; i++) {
if (maxval < dp[i] + dp2[i + 1]) {
maxval = dp[i] + dp2[i + 1];
posi = pos[i];
posj = pos2[i + 1];
}
}
cout << posi << " " << posj << endl;
}
| 2 |
//Author:xht37
#include <bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double
#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair
#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)
#define vi vector <int>
#define pb push_back
#define pq priority_queue
#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)
using namespace std;
namespace io {
const int SI = 1 << 21 | 1;
char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
int f, t;
#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
inline void flush() {
fwrite(OB, 1, OS - OB, stdout), OS = OB;
}
inline void pc(char x) {
*OS++ = x;
if (OS == OT) flush();
}
template <class I>
inline void rd(I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
x *= f;
}
template <class I>
inline void rd(I &x, I &y) {
rd(x), rd(y);
}
template <class I>
inline void rd(I &x, I &y, I &z) {
rd(x), rd(y), rd(z);
}
template <class I>
inline void rda(I *a, int n) {
for (int i = 1; i <= n; i++) rd(a[i]);
}
inline void rdc(char &c) {
for (c = gc(); c < 33 || c > 126; c = gc());
}
inline void rds(char *s, int &n) {
for (c = gc(); c < 33 || c > 126; c = gc());
for (n = 0; c >= 33 && c <= 126; s[++n] = c, c = gc());
s[n+1] = '\0';
}
inline void rds(string &s) {
for (c = gc(); c < 33 || c > 126; c = gc());
for (s.clear(); c >= 33 && c <= 126; s.pb(c), c = gc());
}
template <class I>
inline void print(I x, char k = '\n') {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) ch[++t] = x % 10 + '0', x /= 10;
while (t) pc(ch[t--]);
pc(k);
}
template <class I>
inline void print(I x, I y) {
print(x, ' '), print(y);
}
template <class I>
inline void print(I x, I y, I z) {
print(x, ' '), print(y, ' '), print(z);
}
template <class I>
inline void printa(I *a, int n) {
for (int i = 1; i <= n; i++) print(a[i], " \n"[i==n]);
}
inline void printc(char c) {
pc(c);
}
inline void prints(char *s, int n) {
for (int i = 1; i <= n; i++) pc(s[i]);
pc('\n');
}
inline void prints(string s) {
int n = s.length();
while (t < n) pc(s[t++]);
pc('\n'), t = 0;
}
struct Flush {
~Flush() {
flush();
}
} flusher;
}
using io::rd;
using io::rda;
using io::rdc;
using io::rds;
using io::print;
using io::printa;
using io::printc;
using io::prints;
const int N = 1e5 + 7;
int n, m, a[N], b[N], c[N], d[N], f[N], s[N];
bool v[N];
vi p1, p2, p3, p4;
ll ans, cnt, sum, now;
int get(int x) {
return x == f[x] ? x : (f[x] = get(f[x]));
}
int main() {
// fl("1");
rd(n, m);
for (int i = 1; i <= n; i++) f[i] = i, v[i] = 1;
for (int i = 1; i <= m; i++)
rd(a[i], b[i], c[i]), ++d[a[i]],
f[get(a[i])] = get(b[i]), ans += a[i] != b[i];
for (int i = 1; i <= n; i++) {
++s[get(i)];
if (d[i] != 1) v[get(i)] = 0;
}
for (int i = 1; i <= n; i++)
cnt += get(i) == i && v[i] && s[i] > 1;
if (!cnt) return print(ans), 0;
ans += cnt;
for (int i = 1; i <= m; i++) {
if (c[i] == 1) continue;
int x = get(i);
if (v[x] && s[x] == 1) p1.pb(c[i] - 2);
if (v[x] && s[x] > 1) p2.pb(c[i] - 1);
if (!v[x] && a[i] == b[i]) p3.pb(c[i] - 1);
if (!v[x] && a[i] != b[i]) p4.pb(c[i] - 1);
}
for (int x : p1) sum += x;
for (int x : p2) sum += x;
for (int x : p3) sum += x;
for (int x : p4) sum += x;
// dbg(sum), dbg(cnt), dbg(p3.size()), dbg(p4.size());
if (sum < cnt || (p3.empty() && p4.empty())) return print(-1), 0;
sort(p1.begin(), p1.end());
sort(p2.begin(), p2.end());
sort(p3.begin(), p3.end());
sort(p4.begin(), p4.end());
if (p4.size()) cnt -= p4.back(), p4.pop_back();
else ++ans, cnt -= p3.back(), p3.pop_back();
for (int x : p2) cnt -= x;
for (int x : p4) cnt -= x;
if (cnt <= 0) return print(ans), 0;
now = ans, ans = 1e18, sum = 0;
for (int x : p3) sum += x;
for (int i = p1.size(), j = 0; ~i; i--) {
if (i < (int)p1.size()) sum += p1[i];
while (j < (int)p3.size() && sum - p3[j] >= cnt) sum -= p3[j++];
if (sum >= cnt) ans = min(ans, now + 2 * ((int)p1.size() - i) + ((int)p3.size() - j));
}
// dbg(ans);
print(ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int MAXN = 1e2 + 5;
const long long MOD = 1e9 + 7;
int a[1005][3000];
int main() {
int n, s, d;
int maxx = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s >> d;
for (int j = s; j <= 100000000; j += d) {
if (j > maxx) {
maxx = j;
break;
}
}
}
cout << maxx << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
vector<int> G[maxn];
vector<int> leaves;
int dep[maxn];
int fa[maxn];
void dfs(int u) {
bool leaf = true;
for (auto v : G[u]) {
if (dep[v] == 0) {
leaf = false;
fa[v] = u;
dep[v] = dep[u] + 1;
dfs(v);
}
}
if (leaf) leaves.push_back(u);
}
void print(int s, int t) {
while (s != t) {
cout << s << " ";
s = fa[s];
}
cout << s << endl;
}
int main() {
std::ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
int x, y;
for (int i = 1; i <= m; ++i) {
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
dep[1] = 1;
dfs(1);
for (int i = 1; i <= n; ++i) {
if (dep[i] >= ceil(n * 1.0 / k)) {
cout << "PATH" << endl;
cout << dep[i] << endl;
print(i, 1);
return 0;
}
}
cout << "CYCLES" << endl;
for (auto u : leaves) {
bool flag = false;
vector<int> ancestor;
for (auto v : G[u]) {
if (v != fa[u]) {
if ((dep[u] - dep[v] + 1) % 3 != 0) {
cout << dep[u] - dep[v] + 1 << endl;
print(u, v);
flag = true;
break;
} else {
ancestor.push_back(v);
}
}
}
if (!flag) {
if (dep[ancestor[0]] > dep[ancestor[1]]) {
swap(ancestor[0], ancestor[1]);
}
cout << dep[ancestor[1]] - dep[ancestor[0]] + 2 << endl;
cout << u << " ";
print(ancestor[1], ancestor[0]);
}
k--;
if (k == 0) break;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int n =0;
for(int i=0;i<3;i++){
if(S.at(i)=='R'){
n++;
}
}
if(n==2 && S.at(1)=='S'){
n --;
}
cout << n << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin >> T;
while (T--) {
int a, b;
cin >> a >> b;
string s;
cin >> s;
int n = s.size();
int first = n, last = -1;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
first = min(first, i);
last = max(last, i);
}
}
if (first > last) {
cout << "0\n";
continue;
}
vector<int> len;
int temp = 0;
for (int i = first; i <= last; i++) {
if (s[i] == '0') {
temp++;
} else {
if (temp == 0)
continue;
else
len.push_back(temp);
temp = 0;
}
}
int ans = 0;
for (int var : len) {
int opt1 = var * b;
int opt2 = a;
ans += min(opt1, opt2);
}
ans += a;
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[2222][2222], out[2222][2222], was[2222][2222];
int n, m;
int dx[] = {-1, -1, -1, 0, 1, 1, 1, 0}, dy[] = {-1, 0, 1, 1, 1, 0, -1, -1};
void dfs(int i, int j, vector<int>& x, vector<int>& y) {
if (i < 0 || j < 0 || i >= n || j >= m) return;
if (was[i][j] || a[i][j] != 1) return;
was[i][j] = true;
x.push_back(i);
y.push_back(j);
dfs(i - 1, j, x, y);
dfs(i + 1, j, x, y);
dfs(i, j + 1, x, y);
dfs(i, j - 1, x, y);
}
void OUTPUT() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cout << out[i][j] << " ";
cout << endl;
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
out[i][j] = a[i][j];
}
}
vector<pair<int, int> > centers;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j)
if (a[i][j] == 1 && !was[i][j]) {
vector<int> sx;
vector<int> sy;
dfs(i, j, sx, sy);
nth_element(sx.begin(), sx.begin() + sx.size() / 2, sx.end());
nth_element(sy.begin(), sy.begin() + sy.size() / 2, sy.end());
centers.push_back(make_pair(sx[sx.size() / 2], sy[sy.size() / 2]));
out[sx[sx.size() / 2]][sy[sy.size() / 2]] = 4;
}
}
set<pair<int, int> > l;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j)
if (a[i][j] == 1) {
int nei = 0;
for (int k = 0; k < 8; ++k) {
int x = i + dx[k];
int y = j + dy[k];
if (x >= 0 && x < n && y >= 0 && y < m) nei += a[x][y] == 1;
}
if (nei <= 3) {
bool fnd = false;
for (int dx = -3; !fnd && dx <= 3; ++dx)
for (int dy = -3; dy <= 3; ++dy) {
if (l.find(make_pair(i + dx, j + dy)) != l.end()) {
fnd = true;
break;
}
}
if (!fnd) {
l.insert(make_pair(i, j));
out[i][j] = 2;
}
}
}
}
vector<vector<pair<int, int> > > luch(centers.size());
vector<pair<int, int> > ll(l.begin(), l.end());
for (int j = 0; j < ll.size(); ++j) {
double mind = 1e100;
int ans = 0;
for (int i = 0; i < centers.size(); ++i) {
double d = sqrt(((ll[j].first - centers[i].first) *
(ll[j].first - centers[i].first)) +
((ll[j].second - centers[i].second) *
(ll[j].second - centers[i].second)));
if (d < mind) {
mind = d;
ans = i;
}
}
luch[ans].push_back(ll[j]);
}
vector<int> ans;
for (int i = 0; i < centers.size(); ++i) {
vector<double> ratios;
int cnt = 0;
for (int j = 0; j < luch[i].size(); ++j) {
int cntone = 0;
for (int dxx = -4; dxx <= 4; dxx++)
for (int dyy = -4; dyy <= 4; dyy++) {
int xx = luch[i][j].first + dxx;
int yy = luch[i][j].second + dyy;
if (xx >= 0 && yy >= 0 && xx < n && yy < m) {
out[xx][yy] = 7;
cntone += a[xx][yy] == 1;
}
}
if (cntone < 27) ratios.push_back(cntone);
out[luch[i][j].first][luch[i][j].second] = cntone;
}
ans.push_back(ratios.size());
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 6 |
#include <iostream>
using namespace std;
int main(){
int a,b;
while(1){
a=-1;
int ret = 0;
int data[102]={0};
while(cin >> a >> b && a || b){
a--;b--;
data[a]++;
data[b]++;
}
if(data[0]%2==0 || data[1]%2==0)ret = 10000;
for(int i=0;i<102;i++){
if(data[i]%2==1 && data[i]){
ret++;
}
}
if(a==-1)return 0;
cout << (ret>2?"NG":"OK") << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
vector<vector<int> > g;
vector<bool> u1, u2;
int c = 0;
void dfs1(int v) {
u1[v] = 1;
for (auto i : g[v])
if (!u1[i]) dfs1(i);
}
void dfs2(int v) {
++c;
u2[v] = 1;
for (auto i : g[v])
if (!u2[i]) dfs2(i);
}
int main() {
ios_base::sync_with_stdio(0);
int ans = 0, n, m, s;
vector<pair<int, int> > q;
cin >> n >> m >> s;
--s;
g.resize(n);
u1.assign(n, 0);
u2.assign(n, 0);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].push_back(b);
}
dfs1(s);
for (int i = 0; i < n; ++i)
if (!u1[i]) {
c = 0;
dfs2(i);
q.push_back({-c, i});
u2.assign(n, 0);
}
sort(q.begin(), q.end());
u1.assign(n, 0);
for (auto i : q)
if (!u1[i.second]) {
dfs1(i.second);
++ans;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, d[maxn];
long long l[maxn][2], r[maxn][2], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) scanf("%d", &d[i]);
l[0][0] = l[0][1] = 0;
for (int i = 1; i < n; i++) {
l[i][1] = d[i] < 2 ? 0 : l[i - 1][1] + d[i] / 2 * 2;
if (d[i] & 1)
l[i][0] = l[i - 1][0] + d[i];
else
l[i][0] = max(l[i][1], l[i - 1][0] + d[i] - 1);
}
r[n - 1][0] = r[n - 1][1] = 0;
for (int i = n - 2; i >= 0; i--) {
r[i][1] = d[i + 1] < 2 ? 0 : r[i + 1][1] + d[i + 1] / 2 * 2;
if (d[i + 1] & 1)
r[i][0] = r[i + 1][0] + d[i + 1];
else
r[i][0] = max(r[i][1], r[i + 1][0] + d[i + 1] - 1);
}
ans = (long long)0;
for (int i = 0; i < n; i++)
ans = max(
ans,
max(r[i][0], max(l[i][0], max(l[i][1] + r[i][0], r[i][1] + l[i][0]))));
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1E-8;
const int dx4[4] = {1, 0, 0, -1};
const int dy4[4] = {0, -1, 1, 0};
const int inf = 0x3f3f3f3f;
const int N = 1E5 + 7;
int tree[2][N];
int a[N], p[N];
int n;
long long k;
int lowbit(int x) { return x & (-x); }
void update(int o, int x, int delta) {
if (!o) x = n - x + 1;
for (int i = x; i <= n; i += lowbit(i)) tree[o][i] += delta;
}
int Hash(int x) { return lower_bound(p + 1, p + n + 1, x) - p; }
int Sum(int o, int x) {
if (!o) x = n - x + 1;
int res = 0;
for (int i = x; i >= 1; i -= lowbit(i)) res += tree[o][i];
return res;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%d", a + i), p[i] = a[i];
sort(p + 1, p + n + 1);
long long total = 0;
for (int i = n; i >= 1; i--) {
int x = Hash(a[i]);
a[i] = x;
total += Sum(1, a[i] - 1);
update(1, a[i], 1);
}
int r = 1;
long long ans = 0;
for (int l = 1; l <= n; l++) {
total += Sum(0, a[l] + 1) + Sum(1, a[l] - 1);
update(0, a[l], 1);
while ((r <= l || total > k) && r <= n) {
total -= Sum(0, a[r] + 1) + Sum(1, a[r] - 1);
update(1, a[r], -1);
r++;
}
ans += n - r + 1;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
while (c--) {
if (a <= b)
a++;
else
b++;
}
cout << min(a, b) * 2;
}
| 1 |
#include "bits/stdc++.h"
using namespace std;
using ld = double;
using Point = std::complex<ld>;
const ld eps = 1e-9, pi = acos(-1.0);
namespace std
{
bool operator<(const Point &lhs, const Point &rhs)
{
if (lhs.real() < rhs.real() - eps)
return true;
if (lhs.real() > rhs.real() + eps)
return false;
return lhs.imag() < rhs.imag();
}
} // namespace std
Point input_point()
{
ld x, y;
std::cin >> x >> y;
return Point(x, y);
}
bool eq(ld a, ld b)
{
return (abs(a - b) < eps);
}
ld dot(Point a, Point b)
{
return real(conj(a) * b);
}
ld cross(Point a, Point b)
{
return imag(conj(a) * b);
}
// CCW::counter clockwise
int ccw(Point a, Point b, Point c)
{
b -= a;
c -= a;
if (cross(b, c) > eps)
return 1; // a,b,c : counter-clockwise
if (cross(b, c) < -eps)
return -1; // a,b,c : clockwise
if (dot(b, c) < 0)
return 2; // c,a,b : on a line
if (norm(b) < norm(c))
return -2; // a,b,c : on a line
return 0; // a,c,b : on a line
}
class Line
{
public:
Point a, b;
Line() : a(Point(0, 0)), b(Point(0, 0)) {}
Line(Point a, Point b) : a(a), b(b) {}
};
ld dot(Line l, Line m)
{
return dot((l.a - l.b), (m.a - m.b));
}
// l:line, m:line が交点を持つか
bool isis_ll(Line l, Line m)
{
return !eq(cross(l.b - l.a, m.b - m.a), 0);
}
// l:line, s:segment
bool isis_ls(Line l, Line s)
{
return isis_ll(l, s) &&
(cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < eps);
}
// s:segment, t:segment
bool isis_ss(Line s, Line t)
{
return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
// p が l:line 上に存在するか
bool isis_lp(Line l, Point p)
{
return (abs(cross(l.b - p, l.a - p)) < eps);
}
bool isis_sp(Line s, Point p)
{
return (abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps);
}
// p から l に下ろした足との交点
Point proj(Line l, Point p)
{
ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
return l.a + t * (l.a - l.b);
}
// l:line, t:line の交点
Point is_ll(Line l, Line m)
{
Point lv = l.b - l.a, mv = m.b - m.a;
assert(cross(lv, mv) != 0);
return l.a + lv * cross(mv, m.a - l.a) / cross(mv, lv);
}
// p, l:line の距離
ld dist_lp(Line l, Point p)
{
return abs(p - proj(l, p));
}
ld dist_ll(Line l, Line m)
{
return isis_ll(l, m) ? 0 : dist_lp(l, m.a);
}
ld dist_ls(Line l, Line s)
{
return isis_ls(l, s) ? 0 : std::min(dist_lp(l, s.a), dist_lp(l, s.b));
}
ld dist_sp(Line s, Point p)
{
Point r = proj(s, p);
return isis_sp(s, r) ? abs(r - p) : std::min(abs(s.a - p), abs(s.b - p));
}
ld dist_ss(Line s, Line t)
{
if (isis_ss(s, t))
return 0;
return std::min({dist_sp(s, t.a), dist_sp(s, t.b), dist_sp(t, s.a), dist_sp(t, s.b)});
}
class Circle
{
public:
Point p;
ld r;
Circle() : p(Point(0, 0)), r(0) {}
Circle(Point p, ld r) : p(p), r(r) {}
};
// c1, c2 の交点
std::vector<Point> is_cc(Circle c1, Circle c2)
{
std::vector<Point> res;
ld d = abs(c1.p - c2.p);
ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
ld dfr = c1.r * c1.r - rc * rc;
if (abs(dfr) < eps)
dfr = 0.0;
else if (dfr < 0.0)
return res; // no intersection
ld rs = sqrt(dfr);
Point diff = (c2.p - c1.p) / d;
res.emplace_back(c1.p + diff * Point(rc, rs));
if (dfr != 0.0)
res.emplace_back(c1.p + diff * Point(rc, -rs));
return res;
}
std::vector<Point> is_lc(Circle c, Line l)
{
std::vector<Point> res;
ld d = dist_lp(l, c.p);
if (d < c.r + eps)
{
ld len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d); //safety;
Point nor = (l.a - l.b) / abs(l.a - l.b);
res.emplace_back(proj(l, c.p) + len * nor);
res.emplace_back(proj(l, c.p) - len * nor);
}
return res;
}
std::vector<Point> is_sc(Circle c, Line l)
{
std::vector<Point> v = is_lc(c, l), res;
for (Point p : v)
if (isis_sp(l, p))
res.emplace_back(p);
return res;
}
// p から c への接線
std::vector<Line> tangent_cp(Circle c, Point p)
{
std::vector<Line> ret;
Point v = c.p - p;
ld d = abs(v);
ld l = sqrt(norm(v) - c.r * c.r);
if (isnan((long double)l))
{
return ret;
}
Point v1 = v * Point(l / d, c.r / d);
Point v2 = v * Point(l / d, -c.r / d);
ret.emplace_back(Line(p, p + v1));
if (l < eps)
return ret;
ret.emplace_back(Line(p, p + v2));
return ret;
}
bool isContain(Circle c, Line l)
{
return dist_sp(l, c.p) + eps < c.r;
}
class minCostFlow
{
using capacity_type = int;
using cost_type = double;
using pii = std::pair<cost_type, int>;
const int INF = 1e9;
struct Edge
{
int to, rev;
capacity_type cap;
cost_type cost;
Edge(int to_, int _rev, capacity_type cap_, cost_type cost_)
: to(to_), rev(_rev), cap(cap_), cost(cost_) {}
};
int V;
std::vector<std::vector<Edge>> G;
// ポテンシャル
std::vector<cost_type> h;
// 最短距離
std::vector<cost_type> dist;
// 直前の頂点, 辺
std::vector<int> prevv, preve;
public:
minCostFlow(int _V) : V(_V), G(_V), h(_V), dist(_V), prevv(_V), preve(_V) {}
void add(int from, int to, capacity_type cap, cost_type cost)
{
G[from].push_back(Edge(to, G[to].size(), cap, cost));
G[to].push_back(Edge(from, G[from].size() - 1, 0, -cost));
}
cost_type calc(int s, int t, int f)
{
cost_type res = 0;
fill(h.begin(), h.end(), 0);
while (f > 0)
{
std::priority_queue<pii, std::vector<pii>, std::greater<pii>> que;
fill(dist.begin(), dist.end(), INF);
dist[s] = 0;
que.push(pii(0, s));
while (!que.empty())
{
pii p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (size_t i = 0; i < G[v].size(); i++)
{
Edge &e = G[v][i];
if (e.cap > eps && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to] + eps)
{
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push(pii(dist[e.to], e.to));
}
}
}
if (dist[t] == INF)
return -1;
for (int v = 0; v < V; v++)
h[v] += dist[v];
capacity_type d = f;
for (int v = t; v != s; v = prevv[v])
{
d = std::min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v])
{
Edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
};
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
ld x1, y1, r1, x2, y2, r2;
cin >> x1 >> y1 >> r1 >> x2 >> y2 >> r2;
Circle c1(Point(x1, y1), r1), c2(Point(x2, y2), r2);
vector<Point> rs, bs;
for (int i = 0; i < n; i++)
{
rs.push_back(input_point());
}
for (int i = 0; i < n; i++)
{
bs.push_back(input_point());
}
// dist[i][j] := rs[i], bs[j] の最短移動距離
vector<vector<ld>> dist(n, vector<ld>(n, 1e15));
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
Line l = Line(rs[i], bs[j]);
if (is_sc(c1, l).size() <= 1 && is_sc(c2, l).size() <= 1)
{
dist[i][j] = abs(rs[i] - bs[j]);
continue;
}
// rs[i] から c1 への接線
auto rl1 = tangent_cp(c1, rs[i]);
// bs[j] から c1 への接線
auto bl1 = tangent_cp(c1, bs[j]);
// rs[i], c2 への接線
auto rl2 = tangent_cp(c2, rs[i]);
// bs[j], c2 への接線
auto bl2 = tangent_cp(c2, bs[j]);
for (auto l1 : rl1)
{
for (auto l2 : bl1)
{
Point lv = l1.b - l1.a, mv = l2.b - l2.a;
if (cross(lv, mv) == 0)
continue;
Point p = is_ll(l1, l2);
if (isContain(c2, Line(rs[i], p)) || isContain(c2, Line(bs[j], p)))
continue;
dist[i][j] = min(dist[i][j], abs(p - rs[i]) + abs(p - bs[j]));
}
}
for (auto l1 : rl2)
{
for (auto l2 : bl2)
{
Point lv = l1.b - l1.a, mv = l2.b - l2.a;
if (cross(lv, mv) == 0)
continue;
Point p = is_ll(l1, l2);
if (isContain(c1, Line(rs[i], p)) || isContain(c1, Line(bs[j], p)))
continue;
dist[i][j] = min(dist[i][j], abs(p - rs[i]) + abs(p - bs[j]));
}
}
// rs[i]-c1, bs[j]-c2
for (auto l1 : rl1)
{
for (auto l2 : bl2)
{
Point lv = l1.b - l1.a, mv = l2.b - l2.a;
if (cross(lv, mv) == 0)
continue;
Point p = is_ll(l1, l2);
if (isContain(c2, Line(rs[i], p)) || isContain(c1, Line(bs[j], p)))
continue;
dist[i][j] = min(dist[i][j], abs(p - rs[i]) + abs(p - bs[j]));
}
}
// rs[i]-c2, bs[j]-c1
for (auto l1 : rl2)
{
for (auto l2 : bl1)
{
Point lv = l1.b - l1.a, mv = l2.b - l2.a;
if (cross(lv, mv) == 0)
continue;
Point p = is_ll(l1, l2);
if (isContain(c1, Line(rs[i], p)) || isContain(c2, Line(bs[j], p)))
continue;
dist[i][j] = min(dist[i][j], abs(p - rs[i]) + abs(p - bs[j]));
}
}
}
}
minCostFlow mcf(2 * n + 2);
for (int i = 0; i < n; i++)
{
mcf.add(0, i + 1, 1, 0);
mcf.add(n + i + 1, 2 * n + 1, 1, 0);
for (int j = 0; j < n; j++)
{
int st = i + 1, gt = n + 1 + j;
if (dist[i][j] != 1e15)
{
mcf.add(st, gt, 1, dist[i][j]);
}
}
}
auto ret = mcf.calc(0, 2 * n + 1, n);
if (ret == -1)
cout << "Impossible" << endl;
else
cout << fixed << setprecision(10) << ret << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n <= 9)
printf("1\n%d", n);
else {
printf("%d\n1", n);
for (int i = 2; i <= n; i++) printf(" 1");
printf("\n");
}
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <cstring>
#include <complex>
#include <functional>
#include <cmath>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define rep1(i,n) for(int i=1;i<=(n);++i)
#define all(c) (c).begin(),(c).end()
#define fs first
#define sc second
#define pb push_back
#define show(x) cout << #x << " " << x << endl
typedef double D;
typedef complex<D> P;
typedef vector<P> Pol;
int N,M;
D eps=1e-9;
D cx[100],cy[100],cr[100];
P cp[100];
int ibase;
vector<int> arounds[100];
vector<Pol> Pols;
bool comp(const int& l,const int& r){
P a=cp[l]-cp[ibase],b=cp[r]-cp[ibase];
return arg(a)<arg(b);
}
bool in(int id,P p){
return abs(cp[id]-p)<cr[id];
}
bool contain(Pol pol,P p){
bool in=false;
rep(i,pol.size()){
P a=pol[i]-p,b=pol[(i+1)%pol.size()]-p;
if(imag(a)>imag(b)) swap(a,b);
if(imag(a)<eps&&eps<imag(b)&&imag(conj(a)*b)>eps) in=!in;
}
return in;
}
bool can(P sp,P gp){
rep(i,N){
if(in(i,sp)!=in(i,gp)) return false;
}
rep(i,N){
if(in(i,sp)&&in(i,gp)) return true;
}
for(auto pol:Pols){
if(contain(pol,sp)!=contain(pol,gp)) return false;
}
return true;
}
bool intersect(int i,int j){
if(i==j) return false;
D d=abs(cp[i]-cp[j]);
if(d>cr[i]+cr[j]) return false;
if(d+cr[i]<cr[j]||d+cr[j]<cr[i]) return false;
return true;
}
int main(){
while(true){
cin>>N>>M;
if(N==0) break;
rep(i,N) arounds[i].clear();
Pols.clear();
rep(i,N) cin>>cx[i]>>cy[i]>>cr[i];
rep(i,N) cp[i]=P(cx[i],cy[i]);
rep(i,N){
ibase=i;
rep(j,N) if(intersect(i,j)) arounds[i].pb(j);
sort(all(arounds[i]),comp);
}
/* rep(i,N){
for(auto j:arounds[i]) cout<<j<<" ";
puts("");
}*/
bool use[100][100]={};
rep(i,N){
for(auto j:arounds[i]){
if(use[i][j]) continue;
Pol pol;
int s=i,t=j;
do{
// show(s);
// show(t);
pol.pb(cp[s]);
use[s][t]=true;
ibase=s;
/* vector<int>::iterator it=upper_bound(all(arounds[s]),t,comp);
if(it==arounds[s].end()){
it=arounds[s].begin();
puts("HERE");
}
t=s,s=*it;*/
int nxt=0;
rep(k,arounds[s].size()){
if(arounds[s][k]==t){
nxt=k+1;
break;
}
}
if(nxt==arounds[s].size()) nxt=0;
nxt=arounds[s][nxt];
t=s,s=nxt;
}while(s!=i);
Pols.pb(pol);
// cout<<"pol ";
// rep(i,pol.size()) cout<<pol[i]<<" ";
// cout<<endl;
}
}
rep(i,M){
D sx,sy,gx,gy;
cin>>sx>>sy>>gx>>gy;
P sp=P(sx,sy),gp=P(gx,gy);
cout<<(can(sp,gp)?"YES":"NO")<<(i==M-1?"\n":" ");
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a1, a2, a3, a4;
int main() {
scanf("%d%d%d%d", &a1, &a2, &a3, &a4);
if (abs(a3 - a4) > 1) {
printf("-1\n");
return 0;
}
if (a3 != a4) {
if (min(a1, a2) < max(a3, a4)) {
printf("-1\n");
return 0;
}
}
if (a3 == a4) {
if (!(((a1 > a3) && (a2 >= a3)) || ((a1 >= a4) && (a2 > a4)))) {
printf("-1\n");
return 0;
}
}
if (a3 > a4) {
for (int a = 1; a <= a1 - a3; a++) printf("4");
for (int a = 1; a <= a3; a++) printf("47");
for (int a = 1; a <= a2 - a3; a++) printf("7");
printf("\n");
}
if (a3 < a4) {
printf("74");
for (int a = 1; a <= a1 - a4; a++) printf("4");
for (int a = 1; a <= a4 - 2; a++) printf("74");
for (int a = 1; a <= a2 - a4; a++) printf("7");
printf("74");
printf("\n");
}
if (a3 == a4) {
if (a1 == a3) {
for (int a = 1; a <= a4; a++) printf("74");
for (int a = 1; a <= a2 - a4; a++) printf("7");
printf("\n");
} else {
for (int a = 1; a <= a1 - a3 - 1; a++) printf("4");
for (int a = 1; a <= a3; a++) printf("47");
for (int a = 1; a <= a2 - a3; a++) printf("7");
printf("4");
printf("\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y1, m1, d1, y2, m2, d2;
scanf("%d:%d:%d\n%d:%d:%d", &y1, &m1, &d1, &y2, &m2, &d2);
if (m1 < 3) y1--, m1 += 12;
long long ans1 =
365 * y1 + y1 / 4 - y1 / 100 + y1 / 400 + (153 * m1 - 457) / 5 + d1 - 306;
if (m2 < 3) y2--, m2 += 12;
long long ans2 =
365 * y2 + y2 / 4 - y2 / 100 + y2 / 400 + (153 * m2 - 457) / 5 + d2 - 306;
printf("%lld", (ans1 - ans2) > 0 ? (ans1 - ans2) : (ans2 - ans1));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, k;
int main() {
cin >> l >> r >> k;
if (k >= 4) {
for (long long i = l; i + 2 < r; i++)
if (i % 2 == 0) {
cout << 0 << endl
<< 4 << endl
<< i << " " << i + 1 << " " << i + 2 << " " << i + 3 << " "
<< endl;
return 0;
}
}
if (k >= 3) {
long long c = 0, b = l;
while (b) {
b /= 2;
c++;
}
b = 3;
while (--c) b *= 2;
if (b <= r) {
cout << 0 << endl << 3 << endl << l << " " << (l ^ b) << " " << b << endl;
return 0;
}
}
if (k >= 2) {
if (l % 2 == 0) {
cout << 1 << endl << 2 << endl << l << " " << l + 1 << endl;
return 0;
}
if (l % 2 == 1 && l + 2 <= r) {
cout << 1 << endl << 2 << endl << l + 1 << " " << l + 2 << endl;
return 0;
}
if ((l ^ r) < l) {
cout << (l ^ r) << endl << 2 << endl << l << " " << r << endl;
return 0;
}
}
cout << l << endl << 1 << endl << l << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const char nl = '\n';
void solve() {
string a, b;
cin >> a >> b;
if (a == b) {
cout << -1;
return;
}
cout << max(a.size(), b.size());
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main () {
int N;
cin >> N;
vector<long> data(N);
long ans = 0;
for(int i = 0; i < N; i++)cin >> data.at(i);
for(int i = 0; i < N; i++){
if(data.at(i) == i + 1){
ans++;
i++;
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
char S[500005], T[500005], A[MAXN];
struct Node {
int len;
int seriesAns;
int seriesPre;
Node *link, *slink;
map<int, Node *> to;
Node(int _len) : len(_len) {}
int diff() { return len > 0 ? len - link->len : 0; }
};
int pos;
Node *last, *zero;
void init() {
Node *neg1 = new Node(-1);
zero = new Node(0);
neg1->link = neg1->slink = neg1;
zero->link = zero->slink = neg1;
last = neg1;
pos = 0;
}
Node *getLink(Node *v) {
while (pos == v->len || A[pos - v->len - 1] != A[pos]) v = v->link;
return v;
}
void addLetter() {
char c = A[pos];
last = getLink(last);
if (!last->to[c]) {
Node *node = new Node(last->len + 2);
node->link = getLink(last->link)->to[c];
if (!node->link) node->link = zero;
if (node->diff() == node->link->diff()) {
node->slink = node->link->slink;
} else {
node->slink = node->link;
}
last->to[c] = node;
}
last = last->to[c];
++pos;
}
const int INF = 1000000000;
int ans[MAXN], pre[MAXN];
int main() {
scanf("%s%s", S, T);
int m = strlen(S), n = 0;
for (int i = 0; i < m; ++i) {
A[n++] = S[i];
A[n++] = T[i];
}
init();
memset(pre, -1, sizeof(pre));
for (int i = 1; i <= n; ++i) {
ans[i] = INF;
if (i >= 2 && A[i - 1] == A[i - 2]) ans[i] = ans[i - 2];
addLetter();
for (Node *x = last; x->len > 0; x = x->slink) {
x->seriesAns = INF;
if (!((i - x->slink->len - x->diff()) & 1)) {
x->seriesAns = ans[i - x->slink->len - x->diff()];
x->seriesPre = i - x->slink->len - x->diff();
}
if (x->slink != x->link) {
if (x->link->seriesAns < x->seriesAns) {
x->seriesAns = x->link->seriesAns;
x->seriesPre = x->link->seriesPre;
}
}
if (x->seriesAns + 1 < ans[i]) {
ans[i] = x->seriesAns + 1;
pre[i] = x->seriesPre;
}
}
}
if (ans[n] > n) {
printf("-1\n");
return 0;
}
printf("%d\n", ans[n]);
for (int i = n; i;) {
if (pre[i] == -1) {
i -= 2;
} else {
printf("%d %d\n", (pre[i] + 2) / 2, i / 2);
i = pre[i];
}
}
}
| 5 |
#include <bits/stdc++.h>
const int N = 65540;
const int mod = 1e9 + 7;
long long n;
int m, fac[N], inv[N];
int F[N], G[N], rnk[N], Ans;
int ksm(int u, int v, int md) {
int res = 1;
for (; v; v >>= 1, u = 1ll * u * u % md)
if (v & 1) res = 1ll * res * u % md;
return res;
}
inline void swap(int &u, int &v) {
int o = u;
u = v;
v = o;
}
struct Mtt {
int f[3][N], g[3][N], len, Mod[3] = {7 << 26 | 1, 998244353, 479 << 21 | 1};
int p01 = ksm(Mod[0], Mod[1] - 2, Mod[1]);
int p012 = ksm(1ll * Mod[0] * Mod[1] % Mod[2], Mod[2] - 2, Mod[2]);
void init(int *a, int *b, int c) {
for (int i = 0; i < 3; i++) {
int C = ksm(2, c, mod);
for (int j = 0, k = 1; j <= m; j++, k = 1ll * k * C % mod)
f[i][j] = 1ll * a[j] * k % mod;
for (int j = m + 1; j < len; j++) f[i][j] = 0;
for (int j = 0; j <= m; j++) g[i][j] = b[j];
for (int j = m + 1; j < len; j++) g[i][j] = 0;
}
}
void ntt(int *t, int op, int opt) {
int g = 3, g_ = ksm(g, Mod[op] - 2, Mod[op]);
for (int i = 0; i < len; i++)
if (i < rnk[i]) swap(t[i], t[rnk[i]]);
for (int i = 1; i < len; i <<= 1) {
int wn = ksm(~opt ? g : g_, (Mod[op] - 1) / (i << 1), Mod[op]);
for (int j = 0, J = i << 1; j < len; j += J) {
int w = 1;
for (int k = j; k < i + j; k++, w = 1ll * w * wn % Mod[op]) {
int r = 1ll * t[i + k] * w % Mod[op];
t[i + k] = (t[k] - r + Mod[op]) % Mod[op];
t[k] = (t[k] + r) % Mod[op];
}
}
}
if (~opt) return;
int ny = ksm(len, Mod[op] - 2, Mod[op]);
for (int i = 0; i < len; i++) t[i] = 1ll * t[i] * ny % Mod[op];
}
void doit(int *a) {
for (int i = 0; i < 3; i++) ntt(f[i], i, 1);
for (int i = 0; i < 3; i++) ntt(g[i], i, 1);
for (int i = 0; i < 3; i++)
for (int j = 0; j < len; j++) f[i][j] = 1ll * f[i][j] * g[i][j] % Mod[i];
for (int i = 0; i < 3; i++) ntt(f[i], i, -1);
for (int i = 0; i <= m; i++) {
long long j =
1ll * (f[1][i] - f[0][i] + Mod[1]) * p01 % Mod[1] * Mod[0] + f[0][i];
a[i] = (1ll * (f[2][i] - j % Mod[2] + Mod[2]) * p012 % Mod[2] * Mod[0] %
mod * Mod[1] % mod +
j % mod) %
mod;
}
}
} MTT;
void mul(int *a, int *b, int c) {
MTT.init(a, b, c);
MTT.doit(a);
}
int main() {
scanf("%lld%d", &n, &m);
if (n > m) {
puts("0");
return 0;
}
fac[0] = fac[1] = inv[0] = inv[1] = 1;
for (int i = 2; i <= m; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[m] = ksm(fac[m], mod - 2, mod);
for (int i = m - 1; i >= 2; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
for (int i = 1; i <= m; i++) F[i] = inv[i];
G[0] = 1;
int len = 1, _2 = -1;
while (len < m + m + 2) len <<= 1, _2++;
MTT.len = len;
for (int i = 0; i < len; i++) rnk[i] = (rnk[i >> 1] >> 1) | ((i & 1) << _2);
for (int i = 1; n; n >>= 1, mul(F, F, i), i <<= 1)
if (n & 1) mul(G, F, i);
for (int i = 0; i <= m; i++)
Ans = (Ans + 1ll * G[i] * fac[i] % mod * fac[m] % mod * inv[i] % mod *
inv[m - i] % mod) %
mod;
printf("%d\n", Ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
sort(s.begin(), s.end());
int i = 0, natija = 0;
while (i != s.size()) {
int m = upper_bound(s.begin(), s.end(), s[i]) - s.begin();
int l = m - i;
if (l == 1) {
natija++;
} else {
natija += 2;
}
i = m;
}
cout << natija / 2 << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 100010;
long long int arr[maxn];
long long int cumi[maxn];
long long int n, k;
bool ask(long long int start, long long int end) {
long long int cumi_sum = cumi[end] - cumi[start - 1];
long long int lagbe = arr[end] * (end - start + 1);
return k >= (lagbe - cumi_sum);
}
int main() {
scanf("%lld %lld", &n, &k);
for (long long int i = 1; i <= n; i++) {
scanf("%lld", arr + i);
}
sort(arr + 1, arr + n + 1);
for (long long int i = 1; i <= n; i++) {
cumi[i] = cumi[i - 1] + arr[i];
}
long long int ans = 0;
long long int maxi_ans = 0;
for (long long int i = 1; i <= n; i++) {
long long int lo = i;
long long int hi = n;
while (lo < hi) {
long long int mid = (lo + hi) / 2;
if (ask(i, mid)) {
lo = mid + 1;
} else {
hi = mid;
}
}
if (ask(i, lo) == false) lo--;
if (lo >= i) {
long long int temp = lo - i + 1;
if (temp > ans) {
ans = temp;
maxi_ans = arr[lo];
} else if (temp == ans) {
maxi_ans = min(maxi_ans, arr[lo]);
}
}
}
printf("%lld %lld\n", ans, maxi_ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char as[10][10];
int i, j, white = 0, black = 0;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++) {
cin >> as[i][j];
if (as[i][j] == 'Q')
white += 9;
else if (as[i][j] == 'R')
white += 5;
else if (as[i][j] == 'B')
white += 3;
else if (as[i][j] == 'N')
white += 3;
else if (as[i][j] == 'P')
white += 1;
else if (as[i][j] == 'q')
black += 9;
else if (as[i][j] == 'r')
black += 5;
else if (as[i][j] == 'b')
black += 3;
else if (as[i][j] == 'n')
black += 3;
else if (as[i][j] == 'p')
black += 1;
}
if (white == black)
printf("Draw\n");
else if (white > black)
printf("White\n");
else if (white < black)
printf("Black\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> g[N];
void dfs(int u, vector<int>& dep, int par = -1, int h = 0) {
dep[u] = h;
for (int v : g[u]) {
if (v == par) continue;
dfs(v, dep, u, h + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, x;
cin >> n >> x;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
vector<int> dep_r(n + 1);
vector<int> dep_x(n + 1);
dfs(1, dep_r);
dfs(x, dep_x);
int mx = -1;
for (int i = 1; i <= n; i++) {
if (dep_x[i] < dep_r[i]) {
mx = max(mx, dep_r[i] << 1);
}
}
cout << mx << '\n';
}
| 3 |
#include <bits/stdc++.h>
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
int l, r;
int dl, dr;
int getd(int x) {
if (x == 0) return 0;
return 1 + getd(x / 10);
}
long long gs(int bd) {
if (bd == 0) return 0;
return 9 + gs(bd - 1) * 10;
}
int main() {
scanf("%d %d", &l, &r);
dl = getd(l);
dr = getd(r);
long long ans = -1;
for (int i = dl; i <= dr; ++i) {
long long s = gs(i);
if (l <= s / 2 && s / 2 <= r) {
ans = max(ans, (s / 2) * (s - s / 2));
}
if (i == dl) {
ans = max(ans, l * (s - l));
}
if (i == dr) {
ans = max(ans, r * (s - r));
}
}
printf("%lld\n", ans);
return 0;
}
| 1 |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cctype>
#include<cstdlib>
#include<algorithm>
#include<bitset>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<map>
#include<set>
#include<stack>
#include<cmath>
#include<sstream>
#include<fstream>
#include<iomanip>
#include<ctime>
#include<complex>
#include<functional>
#include<climits>
#include<cassert>
#include<iterator>
#include<random>
#include<unordered_set>
#include<unordered_map>
using namespace std;
#define MAX 100002
int n;
int c;
long long int sc[MAX];
vector<pair<long long int, int> > v;
vector<int> bit;
struct st {
int ty;
int t;
long long int p;
st(int a, int b, int c) {
ty = a;
t = b;
p = c;
}
};
vector<st> vv;
void add(int pos, int x) {
pos++;
while (pos < bit.size()) {
bit[pos] += x;
pos += pos & -pos;
}
}
long long int sum(int pos) {
pos++;
long long int res = 0;
while (pos) {
res += bit[pos];
pos -= pos & -pos;
}
return res;
}
int get_id(int team) {
return lower_bound(v.begin(), v.end(), make_pair(-sc[team], team))-v.begin();
}
int main() {
cin >> n >> c;
for (int i = 0; i < n; i++) {
v.push_back(make_pair(0, i));
}
for (int i = 0; i < c; i++) {
int ty;
scanf("%d", &ty);
if (ty == 0) {
long long int t, p;
scanf("%lld%lld", &t, &p);
t--;
sc[t] += p;
v.push_back(make_pair(-sc[t], t));
vv.push_back(st(ty, t, p));
}
else {
int m;
scanf("%d", &m);
vv.push_back(st(ty, m,-1));
}
}
sort(v.begin(), v.end());
bit.assign(v.size() + 100,0);
memset(sc, 0, sizeof(sc));
for (int i = 0; i < n; i++)add(get_id(i), 1);
for (int i = 0; i < vv.size(); i++) {
if (vv[i].ty == 0) {
add(get_id(vv[i].t), -1);
sc[vv[i].t] += vv[i].p;
add(get_id(vv[i].t), 1);
}
else {
int want = vv[i].t;
int mint = 0;
int maxt = v.size() - 1;
while (mint + 1 < maxt) {
int mid = (mint + maxt) / 2;
if (sum(mid) >= want) {
maxt = mid;
}
else {
mint = mid;
}
}
if (sum(mint) >= want) {
maxt = mint;
}
else {
mint = maxt;
}
printf("%d %lld\n", v[mint].second+1,-v[mint].first);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b;
long long sum = 0;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
scanf("%d", &b);
sum += (b - a + 1);
}
printf("%I64d", (k - sum % k) % k);
return 0;
}
| 1 |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
typedef long long int ll;
#define BIG_NUM 2000000000
#define MOD 1000000007
using namespace std;
int main(){
int N,W,ans = 0,sum = 0;
scanf("%d %d",&N,&W);
int* dp = new int[W+1];
int* friends = new int[N+1];
friends[0] = 0;
for(int i = 1; i <= N; i++){
scanf("%d",&friends[i]);
sum += friends[i];
}
sort(friends,friends+(N+1));
if(sum <= W || W < friends[1]){
printf("1\n");
return 0;
}
sum = 0;
for(int i = 1; i <= N; i++){
sum += friends[i-1];
if(sum > W)break;
if(i == N){
ans = (ans + 1)%MOD;
break;
}
for(int a = 0; a <= W; a++)dp[a] = 0;
dp[0] = 1;
for(int a = i+1; a <= N; a++){
for(int b = W-sum; b >= friends[a]; b--){
dp[b] = (dp[b] + dp[b-friends[a]])%MOD;
}
}
for(int a = 0; a <= W-sum; a++){
if(W-sum-a < friends[i]){
ans = (ans + dp[a])%MOD;
}
}
}
printf("%d\n",ans%MOD);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int tc = 1;
vector<string> split(const string &s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " ";
err(++it, args...);
}
const int M = 1e9 + 7;
const long long Inf = (long long)2e18 + 5;
const int N = 2e5 + 5;
long long vis[N], res[N];
int solve() {
int n, b, k;
cin >> n >> b >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
if ((a[i] - k) <= a[i - 1]) {
b += (a[i - 1] - max(0, (a[i] - k)));
} else {
if (b >= ((a[i] - k) - a[i - 1]))
b -= ((a[i] - k) - a[i - 1]);
else {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
return 0;
}
int main() {
int test = 1;
scanf("%d", &test);
while (test--) solve();
return 0;
}
| 2 |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <cstring>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <complex>
#include <stack>
#include <queue>
#include <unordered_set>
#include <unordered_map>
using namespace std;
int dx[] = { 1,1,1,0,-1,-1,-1,0 };
int dy[] = { 1,0,-1,-1,-1,0,1,1 };
int main(void)
{
for (;;)
{
int h, w; cin >> h >> w;
if (!h)break;
vector<string>donut;
for (int i = 0; i < h; ++i)
{
string s; cin >> s;
donut.push_back(s);
}
map<string, int>dic;
for (int i = 0; i < h; ++i)
{
for (int j = 0; j < w; ++j)
{
for (int dir = 0; dir < 8; ++dir)
{
int ii = i, jj = j;
set<pair<int, int>>st;
string str;
for (;;)
{
if (st.count({ ii,jj }))break;
st.insert({ ii,jj });
str.push_back(donut[ii][jj]);
dic[str]++;
ii += dx[dir]; jj += dy[dir];
ii += h;
jj += w;
ii %= h;
jj %= w;
}
}
}
}
string ans = "0";
for (auto page : dic)
{
if (page.second > 1)
{
const string& s = page.first;
if (s.size() > ans.size())
{
ans = s;
}
else if (s.size() == ans.size())
{
if (s < ans)ans = s;
}
}
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, c = 0;
cin >> n;
while (n >= 1) {
if (n % 6 == 0) {
n = n / 6;
c++;
} else if (n % 3 == 0) {
n = n * 2;
c++;
} else if (n == 1) {
cout << c << "\n";
break;
} else {
cout << "-1"
<< "\n";
break;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double const pi = 3.1415926535897932384626433832795;
int const inf = (int)1e9;
long long const inf64 = (long long)2e18;
const string name = "a";
int n;
int main() {
cin >> n;
if (n & 1) {
for (int i = 0; i < (int)n / 2; i++) {
cout << (char)('a' + (i % 2));
cout << (char)('a' + (i % 2));
}
cout << 'c' << endl;
for (int i = 0; i < (int)n / 2; i++) {
cout << (char)('d' + (i % 2));
cout << (char)('d' + (i % 2));
}
cout << 'c' << endl;
cout << 'o';
for (int i = 0; i < (int)n / 2; i++) {
cout << (char)('k' + (i % 2));
cout << (char)('k' + (i % 2));
}
cout << endl << 'o';
for (int i = 0; i < (int)n / 2; i++) {
cout << (char)('y' + (i % 2));
cout << (char)('y' + (i % 2));
}
cout << endl;
return 0;
}
{
for (int i = 0; i < (int)n / 2; i++) {
cout << (char)('a' + (i % 2));
cout << (char)('a' + (i % 2));
}
cout << endl;
for (int i = 0; i < (int)n / 2; i++) {
cout << (char)('d' + (i % 2));
cout << (char)('d' + (i % 2));
}
cout << endl;
cout << 'o';
for (int i = 0; i < (int)n / 2 - 1; i++) {
cout << (char)('k' + (i % 2));
cout << (char)('k' + (i % 2));
}
cout << 'p' << endl << 'o';
for (int i = 0; i < (int)n / 2 - 1; i++) {
cout << (char)('y' + (i % 2));
cout << (char)('y' + (i % 2));
}
cout << 'p' << endl;
return 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> par;
void bryceorz(int v, int p, const vector<vector<int>> &graph) {
par[v] = p;
for (int nxt : graph[v]) {
if (nxt == p) continue;
bryceorz(nxt, v, graph);
}
}
int main() {
int n;
scanf("%d", &n);
vector<double> fail(n);
for (int i = 0; i < n; ++i) scanf("%lf", &fail[i]);
vector<vector<int>> tree(n);
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d %d", &a, &b);
tree[a].push_back(b);
tree[b].push_back(a);
}
par.assign(n, -1);
bryceorz(0, -1, tree);
par.push_back(-1);
fail.push_back(1.0);
par[0] = n;
vector<double> childrenSums(n + 1);
vector<int> childCount(n + 1);
for (int i = 0; i < n; ++i) childrenSums[par[i]] += fail[i];
for (int i = 0; i <= n; ++i)
if (par[i] != -1) ++childCount[par[i]];
double allSum = 0;
for (int i = 0; i < n; ++i) allSum += fail[i];
auto getAns = [&]() {
double ans = 0;
for (int i = 0; i < n; ++i) {
ans += (1 - fail[i]) * fail[par[i]];
}
return ans;
};
double currentAns = getAns();
int q;
scanf("%d", &q);
while (q--) {
int v;
double new_f;
scanf("%d %lf", &v, &new_f);
double d = new_f - fail[v];
double answerChange =
d * childCount[v] - (fail[par[v]] + childrenSums[v]) * d;
currentAns += answerChange;
fail[v] += d;
childrenSums[par[v]] += d;
printf("%.6lf\n", currentAns);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, x, m, a, b, mx, mi;
cin >> n >> x >> m;
mx = x;
mi = x;
int ans = 1;
for (long long i = (0); i < (m); ++i) {
cin >> a >> b;
if (a <= mi && b >= mx) {
ans = b - a + 1;
mi = a;
mx = b;
} else if (a <= mi && b >= mi) {
ans = max(mx, b) - min(a, mi) + 1;
mi = min(a, mi);
mx = max(mx, b);
} else if (a <= mx && b >= mx) {
ans = max(mx, b) - min(a, mi) + 1;
mi = min(a, mi);
mx = max(mx, b);
}
}
cout << ans;
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
cin >> test;
while (test--) solve();
}
| 2 |
#include <bits/stdc++.h>
int main() {
char a[9999], b[9999];
gets(a);
int i, j, n = strlen(a), t, kong = 0;
for (i = 0; i < n; i++) {
t = 0;
if (a[i] == '<') {
while (a[i] != '>') {
b[t++] = a[i++];
}
b[t++] = '>';
b[t++] = '\0';
int flag = 1;
for (j = 0; a[j] != '\0'; j++) {
if (b[j] == '/') flag = 0;
}
if (flag) {
for (j = 0; j < kong; j++) {
printf(" ");
}
kong += 2;
puts(b);
} else {
kong -= 2;
for (j = 0; j < kong; j++) {
printf(" ");
}
puts(b);
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 2139063143;
const int N = 2010;
const int P = 1000000007;
const double eps = 1e-7;
template <typename T>
inline void sc(T &x) {
x = 0;
static int p;
p = 1;
static char c;
c = getchar();
while (!isdigit(c)) {
if (c == '-') p = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c - 48);
c = getchar();
}
x *= p;
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void pr(T x) {
print(x), putchar('\n');
}
template <typename T1, typename T2>
void chkmax(T1 &A, T2 B) {
A = A >= B ? A : B;
}
template <typename T1, typename T2>
void chkmin(T1 &A, T2 B) {
A = A <= B ? A : B;
}
int del(int x) { return x >= P ? x - P : x; }
void add(int &x, int y) { x = del(x + y); }
int n, m, f[N][N], g[N], a[N], b[N];
char s[N];
int main() {
sc(n), sc(m);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) a[i] = 'z' - s[i], b[i] = 26 - a[i] - 1;
f[0][0] = g[0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= m; j++) {
f[i][j] = (long long)b[i] * g[j] % P;
int tmp = 0;
for (int k = i - 1; k >= 0; k--) {
int p = j - (i - k) * (n - i + 1);
if (p < 0) break;
add(tmp, f[k][p]);
}
add(f[i][j], (long long)tmp * a[i] % P);
add(g[j], f[i][j]);
}
pr(g[m]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n == 1)
cout << "1" << endl;
else if (n == 2)
cout << "2" << endl;
else if (n == 3)
cout << "6" << endl;
else {
if (n % 2 == 1)
cout << n * (n - 1) * (n - 2) << endl;
else {
if (n % 3 == 0) {
n--;
cout << n * (n - 1) * (n - 2) << endl;
} else
cout << n * (n - 1) * (n - 3) << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, count = 0, sum = 0;
cin >> n >> k;
int seq[n];
set<int> s;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> seq[i];
s.insert(seq[i]);
}
int d = s.size();
for (int i = 1;; i++) {
s.insert(i);
int dd = s.size();
if (d == dd)
continue;
else {
d = dd;
count++;
if (i + sum <= k) {
sum += i;
v.push_back(i);
} else
break;
}
}
if (count > 0) count--;
cout << count << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
using namespace std;
int gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void solve() {
string s;
cin >> s;
int m = 0, c = 0;
for (int i = 0; i < s.length(); i++) {
if (int(s[i]) > m) {
m = int(s[i]);
}
}
for (int i = 0; i < s.length(); i++) {
if (int(s[i]) == m) {
c++;
}
}
char ch = (char)m;
for (int i = 0; i < c; i++) cout << ch;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 998244353;
const long long int INF = 2000000000;
const long long BIG = 1446803456761533460LL;
const long long int maxn = 200010;
const long long int maxm = 3010;
long long int n, m, a, b;
long long int dp[maxm][maxm];
pair<long long int, long long int> W[maxn];
long long int inv[maxm * 2];
long long int poww(long long int a, long long int b) {
long long int r = 1;
while (b) {
if (b & 1) r = (1LL * (r) * (a)) % MOD;
a = (1LL * (a) * (a)) % MOD;
b >>= 1;
}
return r;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (long long int i = 0; i < n; ++i) {
cin >> W[i].second;
}
for (long long int i = 0; i < n; ++i) {
cin >> W[i].first;
if (W[i].second)
a += W[i].first;
else
b += W[i].first;
}
for (long long int i = 0; i < m * 2 + 10; ++i) {
inv[i] = poww(a + b - m - 5 + i, MOD - 2);
}
dp[0][0] = 1;
for (long long int i = 0; i < m; ++i) {
for (long long int j = 0; j < i + 1; ++j) {
long long int wa = a + j;
long long int wb = b - (i - j);
dp[i + 1][j + 1] =
((dp[i + 1][j + 1]) +
(1LL * dp[i][j] * wa % MOD * inv[wa + wb - (a + b - m - 5)] % MOD)) %
MOD;
dp[i + 1][j] = ((dp[i + 1][j]) + (1LL * dp[i][j] * wb % MOD *
inv[wa + wb - (a + b - m - 5)] % MOD)) %
MOD;
}
}
long long int ea = 0, emplace_back = 0;
for (long long int j = 0; j < m + 1; ++j) {
ea = ((ea) + (1LL * dp[m][j] * j % MOD)) % MOD;
emplace_back = ((emplace_back) + (1LL * dp[m][j] * (m - j) % MOD)) % MOD;
}
long long int inv_a = poww(a, MOD - 2), inv_b = poww(b, MOD - 2);
for (long long int i = 0; i < n; ++i) {
long long int r;
if (W[i].second) {
r = (W[i].first + 1LL * W[i].first * inv_a % MOD * ea % MOD) % MOD;
} else {
r = (W[i].first - 1LL * W[i].first * inv_b % MOD * emplace_back % MOD +
MOD) %
MOD;
}
cout << r << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int size;
int as[200000];
int bs[200000];
int maxseg[19][200000];
int minseg[19][200000];
long long int ans;
int getmin(int l, int r) {
int len = r - l;
int k = l;
int ret = 1000000001;
for (int i = 18; i >= 0; i--) {
if ((len >> i) & 1) {
ret = min(minseg[i][k], ret);
k += 1 << i;
len = r - k;
}
}
return ret;
}
int getmax(int l, int r) {
int len = r - l;
int k = l;
int ret = -1000000001;
for (int i = 18; i >= 0; i--) {
if ((len >> i) & 1) {
ret = max(maxseg[i][k], ret);
k += 1 << i;
len = r - k;
}
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < 200000; i++) {
for (int j = 0; j < 19; j++) {
maxseg[j][i] = -1000000001;
minseg[j][i] = 1000000001;
}
}
for (int i = 0; i < n; i++) {
scanf("%d", &as[i]);
maxseg[0][i] = as[i];
}
for (int i = 0; i < n; i++) {
scanf("%d", &bs[i]);
minseg[0][i] = bs[i];
}
for (int j = 1; j < 19; j++) {
for (int i = 0; i < n; i++) {
int g = i + (1 << (j - 1));
if (g < n) {
maxseg[j][i] = max(maxseg[j - 1][i], maxseg[j - 1][g]);
minseg[j][i] = min(minseg[j - 1][i], minseg[j - 1][g]);
} else {
maxseg[j][i] = maxseg[j - 1][i];
minseg[j][i] = minseg[j - 1][i];
}
}
}
for (int l = 0; l < n; l++) {
int low = 0;
int high = n - l + 1;
while (high - low > 1) {
int mid = (low + high) / 2;
long long int mi = getmin(l, l + mid);
long long int ma = getmax(l, l + mid);
long long int t = ma - mi;
if (t < 0)
low = mid;
else
high = mid;
}
int c = low;
low = 0;
high = n - l + 1;
while (high - low > 1) {
int mid = (low + high) / 2;
long long int mi = getmin(l, l + mid);
long long int ma = getmax(l, l + mid);
long long int t = ma - mi;
if (t <= 0)
low = mid;
else
high = mid;
}
int d = low;
ans += d - c;
}
printf("%lld\n", ans);
}
| 4 |
#include<cstdio>
#define ll long long
const int M=205,N=5005;
int n,m,i,j,v[M][N],t[M],q[M][N];
ll a[N],sum,f[N],ans;
int read(){
char c=getchar();int k=0;for (;c<48||c>57;c=getchar());
for (;c>47&&c<58;c=getchar()) k=(k<<3)+(k<<1)+c-48;return k;
}
void gmax(ll &x,ll k){if (k>x) x=k;}
int main(){
n=read();m=read();
for (i=2;i<=n;i++) a[i]=a[i-1]+read();
for (i=1;i<=n;i++){
for (j=1;j<=m;j++){
int k=read();
for (;t[j]&&k>v[j][t[j]];t[j]--)
f[q[j][t[j]]]-=v[j][t[j]],
f[q[j][t[j]-1]]+=v[j][t[j]];
f[i]+=k;f[q[j][t[j]]]-=k;
q[j][++t[j]]=i;v[j][t[j]]=k;
}
for (j=i,sum=0;j;j--) sum+=f[j],
gmax(ans,sum-a[i]+a[j]);
}
printf("%lld",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int i, t, n;
cin >> t;
while (t--) {
cin >> n;
if (n == 1) {
cout << "8\n";
continue;
}
long long int x = n / 4;
if (n % 4 > 0) x++;
n -= x;
while (n--) cout << "9";
while (x--) cout << "8";
cout << '\n';
}
return 0;
}
| 2 |
#include "bits/stdc++.h"
using namespace std;
static const int N = 100;
int main(){
int n,p[N+1],m[N+1][N+1];
cin>>n;
for (int i = 1; i <= n; ++i) {
cin>>p[i-1]>>p[i];
}
for (int i = 1; i <= n; ++i) {m[i][i]=0;}
for (int l = 2; l <= n; ++l) {
for (int i = 1; i <= n-l+1; ++i) {
int j=i+l-1;
m[i][j]=(1<<21);
for (int k = i; k <= j-1; ++k) {
m[i][j]=min(m[i][j],m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]);
}
}
}
cout<<m[1][n]<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, m, n, mi, cnt;
long long t;
double s, tmp, sum, ans;
while (~scanf("%d", &n)) {
m = 2 * n;
cnt = 0;
sum = 0;
for (i = 1; i <= m; i++) {
scanf("%lf", &s);
t = (long long)s;
if (t == s)
cnt++;
else {
tmp = s - t;
sum += tmp;
}
}
mi = min(n, cnt);
ans = 99999999;
for (i = 0; i <= mi; i++) {
ans = min(ans, fabs(n - i - sum));
}
printf("%.3f\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[20];
int main() {
long long n;
cin >> n;
a[1] = 4;
a[2] = 10;
a[3] = 20;
a[4] = 35;
a[5] = 56;
a[6] = 83;
a[7] = 116;
a[8] = 155;
a[9] = 198;
a[10] = 244;
a[11] = 292;
if (n <= 11)
cout << a[n];
else
cout << a[11] + (n - 11ll) * 49ll;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, b, e, cnt;
bool f, ans = 1;
vector<int> v, r;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0, x; i < n; ++i) {
cin >> x;
v.push_back(x);
r.push_back(i + 1);
if (v[i] != r[i]) {
if (!f)
b = i + 1, f = 1;
else {
e = i + 1;
}
}
}
reverse(v.begin() + b - 1, v.begin() + e);
for (int i = 0; i < n; ++i) {
if (v[i] != r[i]) ans = 0;
}
if (!ans)
cout << "0 0" << endl;
else
cout << b << " " << e << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = (1LL << 22) + 2;
long long n, m;
long long a[N];
bool vis[2][N];
void dfs(long long k, long long cur) {
if (vis[cur][k]) return;
vis[cur][k] = 1;
if (cur == 1) return dfs(k, cur ^ 1);
for (long long i = 0; i < n; i++) {
if ((k & (1LL << i)) == 0) dfs(k | (1LL << i), 0);
}
dfs(((1LL << n) - 1) ^ k, 1);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (long long i = 0; i < N; i++) vis[1][i] = 1;
for (long long i = 1; i <= m; i++) {
cin >> a[i];
vis[1][a[i]] = 0;
}
long long ans = 0;
for (long long i = 1; i <= m; i++) {
if (vis[1][a[i]]) continue;
ans++;
dfs(a[i], 1);
}
cout << ans;
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.