solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int N, M, W;
double a[55][55];
int t[55][55], k[55];
int main(int argc, char *argv[]) {
scanf("%d%d%d", &N, &W, &M);
int i, pos = 0;
double fill = 0, e = (double)W * N / M, rem;
for (i = 0; i < N; i++) {
if (fill + 0.000000001 > e) {
pos++;
fill = 0;
}
if (e - fill + e + 0.000000001 < W) {
printf("NO\n");
return 0;
}
if (e - fill + 0.000000001 > W) {
fill += W;
a[pos][k[pos]] = W;
t[pos][k[pos]] = i;
k[pos]++;
} else {
rem = W - (e - fill);
a[pos][k[pos]] = e - fill;
t[pos][k[pos]] = i;
k[pos]++;
pos++;
a[pos][k[pos]] = rem;
t[pos][k[pos]] = i;
k[pos]++;
fill = rem;
}
}
int j;
printf("YES\n");
for (i = 0; i < M; i++) {
for (j = 0; j < k[i]; j++) {
if (j) printf(" ");
printf("%d %.7lf", t[i][j] + 1, a[i][j]);
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int months[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int n, m, head;
string s;
int input(string temp) {
int val;
stringstream sin;
sin << temp;
sin >> val;
return val;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
getline(cin, s);
while (getline(cin, s)) {
int month = input(s.substr(5, 2));
int day = input(s.substr(8, 2));
int hour = input(s.substr(11, 2));
int min = input(s.substr(14, 2));
int second = input(s.substr(17, 2));
int sec = second + min * 60 + hour * 3600 + day * 24 * 3600;
for (int i = 0; i + 1 < month; i++) sec += months[i] * 24 * 3600;
while (head < (int)v.size() && v[head] + n <= sec) head++;
v.push_back(sec);
if ((int)v.size() - head == m) {
cout << s.substr(0, 19) << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int N = 3000000;
string s;
int n, prev_0[N], prev_1[N], dp[N][2][2][2], dp1[N][2][2][2], k;
void calc() {
prev_0[0] = -1;
prev_1[0] = -1;
if (s[0] == 'B') prev_0[0] = 0;
if (s[0] == 'W') prev_1[0] = 0;
for (int i = 1; i < n; i++) {
prev_0[i] = prev_0[i - 1];
prev_1[i] = prev_1[i - 1];
if (s[i] == 'B')
prev_0[i] = i;
else if (s[i] == 'W')
prev_1[i] = i;
}
}
void add(int& a, int x) {
a += x;
if (a >= MOD) a -= MOD;
}
int sub(int a, int b) { return (MOD + a - b) % MOD; }
int sum(int l, int r, int p, int f1, int f2) {
if (l > r) return 0;
int res = 0;
int l1 = max(l, 0);
if (r != -1) {
if (!l1)
res = dp1[r][p][f1][f2];
else
res = sub(dp1[r][p][f1][f2], dp1[l1 - 1][p][f1][f2]);
}
if (l == -1 && f1 == 0 && f2 == 0) add(res, 1);
return res;
}
int main() {
cin >> n >> k;
cin >> s;
calc();
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
if (s[i] != 'W') {
int l = prev_1[i];
int l1 = max(l, i - k + 1);
for (int f1 = 0; f1 < 2; f1++)
for (int f2 = 0; f2 < 2; f2++) {
if (f1 == 0 && f2 == 1) continue;
add(dp[i][0][f1][f2], sum(l1, i - 1, 1, f1, f2));
if (f1 == 0) continue;
if (l < l1) {
if (f2 != 1) add(dp[i][0][f1][f2], sum(l, l1 - 1, 1, 0, f2));
add(dp[i][0][f1][f2], sum(l, l1 - 1, 1, 1, f2));
}
}
}
if (s[i] != 'B') {
int l = prev_0[i];
int l1 = max(l, i - k + 1);
for (int f1 = 0; f1 < 2; f1++)
for (int f2 = 0; f2 < 2; f2++) {
if (f1 == 0 && f2 == 1) continue;
add(dp[i][1][f1][f2], sum(l1, i - 1, 0, f1, f2));
if (f2 == 0) {
if (f1 == 0) {
add(dp[i][1][f1][f2], sum(l, l1 - 1, 0, f1, f2));
}
continue;
}
if (l < l1) {
add(dp[i][1][f1][f2], sum(l, l1 - 1, 0, f1, 0));
add(dp[i][1][f1][f2], sum(l, l1 - 1, 0, f1, 1));
}
}
}
for (int f1 = 0; f1 < 2; f1++)
for (int f2 = 0; f2 < 2; f2++) {
dp1[i][0][f1][f2] = dp[i][0][f1][f2];
add(dp1[i][0][f1][f2], dp1[i - 1][0][f1][f2]);
dp1[i][1][f1][f2] = dp[i][1][f1][f2];
add(dp1[i][1][f1][f2], dp1[i - 1][1][f1][f2]);
}
}
int ans = 0;
for (int l = 0; l < 2; l++) add(ans, dp[n - 1][l][1][1]);
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, x;
cin >> n >> m;
x = m + n - 1;
cout << x << endl;
for (i = 1; i <= n; i++) cout << i << " " << 1 << endl;
for (i = 2; i <= m; i++) cout << 1 << " " << i << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin>>s;
sort(s.begin(),s.end());
if(s[0]==s[1] && s[1]!=s[2] && s[2]==s[3]){
cout<<"Yes"<<endl;
}
else cout<<"No"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int absol(int x);
int main() {
int n, C, left, right, top, bot;
char c;
int xy[10][2] = {{1, 3}, {0, 0}, {1, 0}, {2, 0}, {0, 1},
{1, 1}, {2, 1}, {0, 2}, {1, 2}, {2, 2}};
cin >> n;
cin >> c;
C = c;
C -= 48;
left = C;
right = C;
top = C;
bot = C;
for (int i = 1; i < n; i++) {
cin >> c;
C = c;
C -= 48;
if (xy[C][0] < xy[left][0])
left = C;
else if (xy[C][0] > xy[right][0])
right = C;
if (xy[C][1] < xy[top][1])
top = C;
else if (xy[C][1] > xy[bot][1] || (bot != 0 && (C == 7 || C == 9)))
bot = C;
}
if ((absol(xy[bot][1] - xy[top][1]) == 2 &&
absol(xy[right][0] - xy[left][0]) == 2 && bot != 8 && bot != 0) ||
absol(xy[bot][1] - xy[top][1]) == 3) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
return 0;
}
int absol(int x) {
if (x < 0)
return x * -1;
else
return x;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int HMAX=100,WMAX=100;
const int m[4][2]={{-1,0},{0,-1},{0,1},{1,0}};
bool p[HMAX][WMAX];
char a[HMAX][WMAX];
int h,w;
void dfs(int x,int y,char l)
{
if(x<0||x>=h)return;
if(y<0||y>=w)return;
if(a[x][y]!=l)return;
if(p[x][y])return;
p[x][y]=true;
for(int i=0;i<4;i++)dfs(x+m[i][0],y+m[i][1],a[x][y]);
}
int main()
{
while(scanf("%d%d",&h,&w)==2)
{
if(h==0&&w==0)break;
int c=0;
memset(p,0,sizeof p);
for(int i=0;i<h;i++)for(int j=0;j<w;j++)scanf(" %c",&a[i][j]);
for(int i=0;i<h;i++)for(int j=0;j<w;j++)if(!p[i][j])dfs(i,j,a[i][j]),++c;
printf("%d\n",c);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(NULL);
int n, cnt = 0, ans = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] != '4' and s[i] != '7') {
cout << "NO";
return 0;
} else if (i < n / 2) {
cnt += int(s[i]);
} else {
ans += int(s[i]);
}
}
if (cnt == ans) {
cout << "YES";
} else {
cout << "NO";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > ans;
void add(int a, int b, int c, int d) { ans.push_back({4, a, b, c, d}); }
void add(int a, int b, int c) { ans.push_back({3, a, b, c}); }
void f(int n) {
if (n == 3) {
add(1, 2, 3);
add(1, 2, 3);
return;
}
if (n == 4) {
add(1, 2, 3);
add(1, 3, 4);
add(1, 2, 4);
add(2, 3, 4);
return;
}
f(n - 2);
for (int i = 1; i <= (n - 3); i++) {
int a = i;
int b = i + 1;
if (b == n - 2) b = 1;
add(n, a, n - 1, b);
}
add(n, n - 2, n - 1);
add(n, n - 2, n - 1);
}
int main() {
int n;
scanf("%d", &n);
f(n);
int s = ans.size();
printf("%d\n", s);
for (int i = 0; i < s; i++) {
for (int j = 0; j < ans[i].size(); j++) printf("%d ", ans[i][j]);
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct vertex {
int zn;
int coun;
int p1;
int sl[10];
int prev;
};
struct number {
int coun;
int ss;
};
int n;
vector<vertex> y(10);
vector<vector<number> > v(70000, vector<number>(9));
vector<vector<int> > res(70000, {-1});
int ost = 0;
int u = 0;
void pruf() {
u++;
vector<int> r(1);
r[0] = -1;
while (ost < (int)y.size()) {
if (y[ost].coun == 1) {
if (res[y[ost].p1] == r) {
res[y[ost].p1] = {};
int q = ost;
while (y[q].prev != -1) {
res[y[ost].p1].push_back(y[q].zn);
q = y[q].prev;
}
res[y[ost].p1].push_back(y[q].zn);
reverse(res[y[ost].p1].begin(), res[y[ost].p1].end());
}
}
ost++;
}
return;
}
int main() {
cin >> n;
for (int i = 0; i < 10; i++) {
y[i].zn = i;
y[i].coun = 0;
for (int j = 0; j < 10; j++) y[i].sl[j] = -1;
y[i].prev = -1;
y[i].p1 = -1;
}
string r;
for (int i = 0; i < n; i++) {
cin >> r;
for (int j = 0; j < 9; j++) {
v[i][j].coun = r[j] - '0';
v[i][j].ss = r[j] - '0';
if (y[v[i][j].ss].p1 != i) {
y[v[i][j].ss].p1 = i;
y[v[i][j].ss].coun++;
}
}
}
pruf();
vertex d;
d.zn = 0;
d.coun = 1;
for (int j = 0; j < 10; j++) d.sl[j] = -1;
d.prev = -1;
d.p1 = -1;
for (int i = 1; i < 9; i++) {
for (int j = 0; j < n; j++) {
for (int k = 8; k >= i; k--) {
if (y[v[j][k - 1].ss].sl[v[j][k].coun] == -1) {
y.push_back(d);
int a = (int)y.size() - 1;
y[a].zn = v[j][k].coun;
y[a].prev = v[j][k - 1].ss;
y[a].p1 = j;
v[j][k].ss = a;
y[v[j][k - 1].ss].sl[v[j][k].coun] = a;
} else {
if (y[y[v[j][k - 1].ss].sl[v[j][k].coun]].p1 == j) {
v[j][k].ss = y[v[j][k - 1].ss].sl[v[j][k].coun];
} else {
v[j][k].ss = y[v[j][k - 1].ss].sl[v[j][k].coun];
y[y[v[j][k - 1].ss].sl[v[j][k].coun]].p1 = j;
y[y[v[j][k - 1].ss].sl[v[j][k].coun]].coun += 1;
}
}
}
}
pruf();
}
for (int i = 0; i < n; i++) {
for (auto j : res[i]) {
cout << j;
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 10000000000000ll;
typedef pair<long long, int> pa;
int V, E, R;
long long dist[100000];
struct edge{ int s, t, d; };
vector<edge> graph[100000];
int main(){
cin >> V >> E >> R;
for(int i = 0; i < E; i++){
edge e;
cin >> e.s >> e.t >> e.d;
graph[e.s].push_back(e);
}
fill(dist, dist + V, inf);
dist[R] = 0;
priority_queue<pa, vector<pa>, greater<pa>> que;
que.push({0, R});
while(!que.empty()){
pa p = que.top();
que.pop();
int v = p.second, d = p.first;
if(dist[v] < d)continue;
for(edge e : graph[v]){
if(dist[e.t] > d + e.d){
dist[e.t] = d + e.d;
que.push({d + e.d, e.t});
}
}
}
for(int i = 0; i < V; i++){
if(dist[i] == inf)cout << "INF\n";
else cout << dist[i] << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200200];
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i < n; i++) {
if (a[i] % 2) {
a[i] = 1;
if (a[i + 1] == 0) {
cout << "NO";
return 0;
} else {
a[i + 1]--;
}
}
}
if (a[n] % 2) {
cout << "NO";
return 0;
}
cout << "YES";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
long long A,B,K;
cin >> A >> B >>K;
cout << max(0LL,A - K) <<" "<<max(0LL,B - max(0LL,K - A))<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
map<string,int>mp;
map<string,int>::iterator it;
int n,x,y=0,count = 0;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>s>>x;
count+=x;
mp[s]=count;
}
cin>>s;
it=mp.find(s);
if(it!=mp.end()) y = it->second;
cout<<count-y<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int cond = 1;
const int max_n = 1011;
int f[2][max_n];
pair<string, int> s[2][max_n];
int pos[2][max_n];
int key[2][max_n];
int r[2][max_n];
pair<int, int> t[max_n];
int find(int id, int a) {
if (f[id][a] != a) f[id][a] = find(id, f[id][a]);
return f[id][a];
}
void link(int id, int a, int b) {
a = find(id, a);
b = find(id, b);
if (a == b) return;
if (r[id][a] > r[id][b]) swap(a, b);
f[id][a] = b;
if (r[id][a] == r[id][b]) ++r[id][b];
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (__typeof(1) i = (1); i <= (m); ++i)
scanf("%d%d", &t[i].first, &t[i].second);
for (int i = 0; i < (2); i++) {
char buf[20];
for (__typeof(1) j = (1); j <= (n); ++j) {
f[i][j] = j;
r[i][j] = 0;
}
for (int j = 0; j < (k); j++) {
scanf("%s", buf);
scanf("%d", &pos[i][j]);
s[i][j].first = buf;
s[i][j].second = pos[i][j];
int a, b;
scanf("%d", &a);
while (a--) {
scanf("%d", &b);
key[i][b] = pos[i][j];
}
}
for (int u = 0; u < (n); u++) {
for (__typeof(1) l = (1); l <= (m); ++l)
if (find(i, t[l].first) != find(i, t[l].second) &&
(find(i, t[l].first) == find(i, key[i][l]) ||
find(i, t[l].second) == find(i, key[i][l]))) {
link(i, t[l].first, t[l].second);
}
}
}
for (int i = 0; i < (2); i++) sort(s[i], s[i] + k);
bool ok = true;
for (int i = 0; i < (k); i++)
for (__typeof(1) j = (1); j <= (n); ++j) {
if ((find(0, s[0][i].second) == find(0, j)) !=
(find(1, s[1][i].second) == find(1, j)))
ok = false;
}
for (__typeof(1) i = (1); i <= (m); ++i)
if (find(0, key[0][i]) != find(0, key[1][i])) ok = false;
puts(ok ? "YES" : "NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int z = 1000000000;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n, x;
cin >> n;
vector<long long int> a(n + 1);
long long int ans = -1;
for (int i = 1; i <= (n + 1) / 2; i++) {
cin >> a[i];
}
cin >> x;
for (int i = (n + 1) / 2 + 1; i <= n; i++) {
a[i] = x;
}
vector<long long int> prefix(n + 1);
a[0] = 0;
prefix[0] = 0;
vector<long long int> prefix2(n + 1);
prefix2[0] = INT_MIN;
for (int i = 1; i <= n; i++) {
prefix[i] = prefix[i - 1] + a[i];
long long int curr_max = prefix[i] - i * x;
prefix2[i] = max(prefix2[i - 1], curr_max);
}
for (long long int i = (n + 1) / 2; i <= n; i++) {
if (prefix[i] > 0 && prefix2[n - i] < prefix[i]) {
ans = i;
break;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define pi (3.141592653589)
#define mod 1000000007
#define float double
#define pb push_back
#define sz(x) (int)(x).size()
#define ff first
#define ss second
#define lb lower_bound
#define pq_max priority_queue<int>
#define pq_min priority_queue<int,vi,greater<int> >
#define trav(a,x) for (auto& a : x)
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define rev(i,n,init) for(int i=n;i>=init;i--)
#define rep(i,j,n) for(int i=j; i<n; i++)
#define ump unordered_map
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef map<int,int> mpii;
const long long INF=1e18;
const int32_t M=1e9+7;
const int32_t MM=998244353;
template<typename T,typename T1>T amax(T &a,T1 b){if(b>a)a=b;return a;}
template<typename T,typename T1>T amin(T &a,T1 b){if(b<a)a=b;return a;}
const int N=10000;
void solve(int test_case) {
string str;
cin >> str;
int n = str.length();
set<int> s;
for(auto ch: str) {
if(s.count(ch - 'a' + 1) == 1) {
cout << "NO\n";
return;
}
s.insert(ch - 'a' + 1);
}
int i = 1;
for(auto el: s) {
if(el != i) {
cout << "NO\n";
return;
}
i++;
}
i = 0;
while(str[i] != 'a') {
i++;
}
int j = i-1;
while(j >= 1) {
if(str[j] > str[j-1]) {
cout << "NO\n";
return;
}
j--;
}
while(i < n-1) {
if(str[i] > str[i+1]) {
cout << "NO\n";
return;
}
i++;
}
cout << "YES\n";
}
int32_t main(){
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
int t =1 ;
cin>>t;
rep(i,1,t+1){
solve(i);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000005 * 5;
const double eps = 1e-9;
const int INF = 0x3f3f3f3f;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int kx[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky[] = {2, -2, 1, -1, 2, -2, 1, -1};
int num[MAX], sum[MAX];
void gen() {
for (int i = 1; i < MAX; i++) {
for (int j = 2 * i; j < MAX; j += i) {
num[j] = num[i] + 1;
}
}
for (int i = 1; i < MAX; i++) sum[i] = sum[i - 1] + num[i];
}
int main() {
gen();
int t;
scanf("%d", &t);
while (t--) {
int a, b;
scanf("%d %d", &a, &b);
printf("%d\n", sum[a] - sum[b]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int power[] = {0, 2, 3, 5, 7, 13,
17, 19, 31, 61, 89, 107,
127, 521, 607, 1279, 2203, 2281,
3217, 4253, 4423, 9689, 9941, 11213,
19937, 21701, 23209, 44497, 86243, 110503,
132049, 216091, 756839, 859433, 1257787, 1398269,
2976221, 3021377, 6972593, 13466917, 20996011, 24036583};
long long int modexp(long long int a, long long int b) {
long long int ret = 1;
while (b) {
if ((b & 1)) {
ret *= a;
ret %= (1000000000 + 7);
}
a *= a;
a %= (1000000000 + 7);
b >>= 1;
}
return ret;
}
int main() {
int x, y, i, n;
scanf("%d", &n);
printf("%I64d\n",
(modexp(2, power[n] - 1) + (1000000000 + 7) - 1) % (1000000000 + 7));
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll a,b,n; cin >> a >> b >> n;
cout << min(n,b-1)*a/b << endl;
}
| 0 |
#include <bits/stdc++.h>
int flag;
bool flag2;
int main(void) {
int n;
int num;
char ch;
char* p;
scanf("%d", &n);
getchar();
while (n--) {
flag = 0;
num = 0;
flag2 = 0;
while ((ch = getchar()) != '\n') {
num += ch - '0';
if (flag < 2 && (ch - '0' & 1) == 0) flag++;
if (!flag2 && ch == '0') flag2 = 1;
}
if (num % 3 == 0 && flag2 && flag == 2)
printf("red");
else
printf("cyan");
if (n) printf("\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
int n, m, k, x, y, nx, ny, ans, rot;
int l[N][N], r[N][N];
int _l(int x, int y) {
if (l[x][y] == y) return y;
return l[x][y] = _l(x, l[x][y]);
}
int _r(int x, int y) {
if (r[x][y] == y) return y;
return r[x][y] = _r(x, r[x][y]);
}
void go(int x, int y) {
if (y < 1 || y > m) return;
int dst = abs(x - ::x) + abs(y - ::y);
if (rot) swap(x, y);
if (dst < ans || (dst == ans && (x < nx || (x == nx && y < ny)))) {
ans = dst;
nx = x;
ny = y;
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> k;
if (n > m) {
swap(n, m);
rot = 1;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) l[i][j] = r[i][j] = j;
while (k--) {
cin >> x >> y;
ans = 1 << 30;
if (rot) swap(x, y);
for (int i = 0; i <= ans; ++i) {
if (x - i >= 1) {
go(x - i, _l(x - i, y));
go(x - i, _r(x - i, y));
}
if (x + i <= n) {
go(x + i, _l(x + i, y));
go(x + i, _r(x + i, y));
}
}
cout << nx << ' ' << ny << '\n';
if (rot) swap(nx, ny);
l[nx][ny] = _l(nx, ny - 1);
r[nx][ny] = _r(nx, ny + 1);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
inline long long read() {
long long X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
long long hsh = 29;
long long mod = 1000000007;
long long n, m, k;
char s[500005], t[5000005];
long long na[500005], pa[500005];
long long hashs[500005];
long long hasht[500005];
long long p[500005];
bool check(long long l, long long r, long long L, long long R) {
return (((hashs[r] - 1LL * hashs[l - 1] * p[r - l + 1]) % mod + mod) % mod) ==
((mod + (hasht[R] - 1LL * hasht[L - 1] * p[R - L + 1]) % mod) % mod);
}
void solve1(long long l, long long r) {
long long pos = k;
for (long long i = l; i <= r; i++) {
while (pos < i) pos++;
while (pos <= n) {
if (check(pos - i + 1, pos, 1, i)) break;
pos++;
}
if (pos <= n) {
na[i] = pos;
} else {
na[i] = 0;
}
}
}
void solve2(long long l, long long r) {
long long pos = n - k + 1;
for (long long i = r; i >= l; i--) {
while (pos + m - i > n) {
pos--;
}
while (pos) {
if (check(pos, pos + m - i, i, m)) break;
pos--;
}
pa[i] = pos;
}
}
void special() {
long long pos = 1;
for (long long i = 1; i <= m; i++) {
while (pos < i) pos++;
while (pos <= n) {
if (check(pos - i + 1, pos, 1, i)) {
break;
}
pos++;
}
}
if (max(pos, k) + k <= n) {
cout << "Yes" << endl;
cout << max(1LL, pos - k + 1) << " " << max(pos, k) + 1 << endl;
exit(0);
}
pos = n;
for (long long i = m; i; i--) {
while (pos + m - i > n) pos--;
while (pos) {
if (check(pos, pos + m - i, i, m)) {
break;
}
pos--;
}
}
if (n - max(n - pos + 1, k) - k > 0) {
cout << "Yes" << endl;
cout << n - max(n - pos + 1, k) - k << " " << n - max(n - pos + 1, k) + 1;
exit(0);
}
}
int main() {
cin >> n >> m >> k;
scanf("%s%s", s + 1, t + 1);
p[0] = 1;
for (long long i = 1; i <= n; i++) {
p[i] = (p[i - 1] * hsh) % mod;
}
for (long long i = 1; i <= n; i++) {
hashs[i] = (hashs[i - 1] * hsh + s[i] - 'a') % mod;
}
for (long long i = 1; i <= m; i++) {
hasht[i] = (hasht[i - 1] * hsh + t[i] - 'a') % mod;
}
if (m <= k) {
special();
}
long long tmp1 = 1;
long long tmp2 = 1;
for (long long i = 1; i <= m and i <= k; i++) {
if (check(k - i + 1, k, 1, i)) {
tmp1 = i;
if (tmp2 != 1) {
tmp2 = i;
}
na[i] = k;
}
}
solve1(1, tmp2 - 1);
solve1(tmp1 + 1, min(m, k));
tmp1 = tmp2 = m;
for (long long i = m; i and i >= m - k + 1; i--) {
if (check(n - k + 1, n - k + 1 + m - i, i, m)) {
tmp1 = i;
if (tmp2 != m) {
tmp2 = i;
}
pa[i] = n - k + 1;
}
}
solve2(tmp2 + 1, m);
solve2(max(1LL, m - k + 1), tmp1 - 1);
long long x = 0, y = 0;
for (long long i = 1; i < m; i++) {
if (na[i] and pa[i + 1] and na[i] < pa[i + 1]) {
x = na[i] - k + 1;
y = pa[i + 1];
break;
}
}
if (x) {
cout << "Yes" << endl;
cout << x << " " << y << endl;
return 0;
}
cout << "No";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 1005;
int SHLF[N][N];
int CNT[N], REV[N], ANS[N * 100];
vector<int> G[N * 100];
pair<int, pair<int, int> > Q[N * 100];
int add_book(int i, int j) {
if ((!SHLF[i][j] && !REV[i]) || (SHLF[i][j] && REV[i])) {
CNT[i]++, SHLF[i][j] ^= 1;
return 1;
}
return 0;
}
int rem_book(int i, int j) {
if ((SHLF[i][j] && !REV[i]) || (!SHLF[i][j] && REV[i])) {
CNT[i]--, SHLF[i][j] ^= 1;
return 2;
}
return 0;
}
int rev(int i, int m) {
REV[i] ^= 1;
CNT[i] = m - CNT[i];
return 3;
}
inline void query(int x, int m) {
if (!x) return;
if (Q[x].first == 1)
ANS[x] -= CNT[Q[x].second.first],
Q[x].first = add_book(Q[x].second.first, Q[x].second.second),
ANS[x] += CNT[Q[x].second.first];
else if (Q[x].first == 2)
ANS[x] -= CNT[Q[x].second.first],
Q[x].first = rem_book(Q[x].second.first, Q[x].second.second),
ANS[x] += CNT[Q[x].second.first];
else if (Q[x].first == 3)
ANS[x] -= CNT[Q[x].second.first], Q[x].first = rev(Q[x].second.first, m),
ANS[x] += CNT[Q[x].second.first];
}
inline void rev_query(int x, int m) {
if (!x) return;
if (Q[x].first == 2)
add_book(Q[x].second.first, Q[x].second.second);
else if (Q[x].first == 1)
rem_book(Q[x].second.first, Q[x].second.second);
else if (Q[x].first == 3)
rev(Q[x].second.first, m);
}
inline void dfs(int x, int p, int m) {
ANS[x] = ANS[p];
query(x, m);
for (auto i : G[x]) dfs(i, x, m);
rev_query(x, m);
}
int main() {
int n, m, q;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &Q[i].first);
if (Q[i].first <= 2)
scanf("%d", &Q[i].second.first), scanf("%d", &Q[i].second.second);
else
scanf("%d", &Q[i].second.first);
if (Q[i].first == 4)
G[Q[i].second.first].push_back(i);
else
G[i - 1].push_back(i);
}
dfs(0, 0, m);
for (int i = 1; i <= q; i++) printf("%d\n", ANS[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T cross(complex<T> a, complex<T> b) {
return imag(a * conj(b));
}
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
void setmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void setmax(T &a, T b) {
if (b > a) a = b;
}
const int MAXN = 200;
const long long MOD = 1000000007;
int N;
string s;
long long powMod(long long p, long long e) {
long long out = 1;
for (int i = 0; i < e; i++) out *= p, out %= MOD;
return out;
}
void io(istream &in, ostream &out) {
in >> s;
N = s.size();
long long ans = 0;
for (int i = 0; i < N; i++) {
if (s[i] == '1') ans += powMod(2, i) * powMod(4, N - i - 1);
ans %= MOD;
}
out << ans << '\n';
}
int main() {
ifstream fin("A.in");
if (fin.good()) {
ofstream fout("A.out");
io(fin, fout);
fin.close();
fout.close();
} else
io(cin, cout);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, key[100000];
vector<int> tree[100000];
int l_min[100000], l_max[100000], r_min[100000], r_max[100000];
void dfs1(int u) {
if (tree[u].empty()) {
l_min[u] = l_max[u] = r_min[u] = r_max[u] = key[u];
return;
}
int vl = tree[u][0];
dfs1(vl);
int vr = tree[u][1];
dfs1(vr);
l_min[u] = l_min[vl];
l_max[u] = r_max[vl];
r_min[u] = l_min[vr];
r_max[u] = r_max[vr];
}
double ex[100000];
void dfs2(int u, double sum, int m) {
if (tree[u].empty()) {
ex[u] = sum / m;
return;
}
int vl = tree[u][0];
dfs2(vl, sum + r_min[u], m + 1);
int vr = tree[u][1];
dfs2(vr, sum + l_max[u], m + 1);
}
int main() {
int root;
scanf("%d", &n);
for (int u = 0; u < (n); u++) {
int p;
scanf("%d%d", &p, key + u);
p--;
if (p == -2)
root = u;
else {
tree[p].push_back(u);
if (tree[p].size() == 2) {
int &v1 = tree[p][0], &v2 = tree[p][1];
if (key[v1] > key[v2]) swap(v1, v2);
}
}
}
dfs1(root);
dfs2(root, 0, 0);
static pair<int, int> order[100000];
for (int u = 0; u < (n); u++) order[u] = make_pair(key[u], u);
sort(order, order + n);
int q;
scanf("%d", &q);
while (q--) {
int k;
scanf("%d", &k);
pair<int, int> *p = lower_bound(order, order + n, make_pair(k, -1));
if (p == order + n || !tree[p->second].empty()) p--;
printf("%.15f\n", ex[p->second]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e6 + 2;
const int inf = 1e9;
int n, m;
pair<int, int> a[maxn];
vector<vector<int> > b;
vector<int> tree[maxn];
int c[maxn];
void build(int v, int ll, int rr) {
if (ll + 1 == rr) {
tree[v].push_back(a[ll].second);
return;
}
build(v * 2 + 1, ll, (ll + rr) / 2);
build(v * 2 + 2, (ll + rr) / 2, rr);
for (int i = 0; i < (int)tree[v * 2 + 1].size(); i++)
tree[v].push_back(tree[v * 2 + 1][i]);
for (int i = 0; i < (int)tree[v * 2 + 2].size(); i++)
tree[v].push_back(tree[v * 2 + 2][i]);
sort(tree[v].begin(), tree[v].end());
}
int getCnt(int v, int ll, int rr, int l, int r, int k) {
if (ll >= r || l >= rr) return 0;
if (l <= ll && rr <= r)
return lower_bound(tree[v].begin(), tree[v].end(), k) - tree[v].begin();
return getCnt(v * 2 + 1, ll, (ll + rr) / 2, l, r, k) +
getCnt(v * 2 + 2, (ll + rr) / 2, rr, l, r, k);
}
void read() {
int k;
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%d%d", &a[i].first, &a[i].second);
b.resize(m);
for (int i = 0; i < m; i++) {
scanf("%d", &k);
b[i].resize(k);
for (int j = 0; j < k; j++) scanf("%d", &b[i][j]);
}
}
vector<int> solve() {
int l, r, res;
vector<int> ans;
sort(a, a + n);
build(0, 0, n);
for (int i = 0; i < m; i++) {
int k = b[i].size();
c[0] = -1;
for (int j = 0; j < k; j++) c[j + 1] = b[i][j];
c[k + 1] = inf;
k += 2;
res = n;
for (int j = 0; j < k - 1; j++) {
l = lower_bound(a, a + n, make_pair(c[j] + 1, -1)) - a;
r = lower_bound(a, a + n, make_pair(c[j + 1], -1)) - a;
res -= getCnt(0, 0, n, l, r, c[j + 1]);
}
ans.push_back(res);
}
return ans;
}
int main() {
vector<int> ans;
read();
ans = solve();
for (int i = 0; i < (int)ans.size(); i++) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
char s1[1000];
char s2[1000];
int len;
int i;
char get(char *s, int i) {
if (s[i] == '[' && s[i + 1] == ']') return 'B';
if (s[i] == '(' && s[i + 1] == ')') return 'K';
if (s[i] == '8' && s[i + 1] == '<') return 'N';
}
int main() {
scanf("%s", s1);
scanf("%s", s2);
len = strlen(s1);
int cnt = 0;
for (i = 0; i < len; i += 2) {
char F = get(s1, i);
char S = get(s2, i);
if (F == 'K' && S == 'N') cnt++;
if (F == 'K' && S == 'B') cnt--;
if (F == 'N' && S == 'B') cnt++;
if (F == 'N' && S == 'K') cnt--;
if (F == 'B' && S == 'K') cnt++;
if (F == 'B' && S == 'N') cnt--;
}
if (cnt > 0) {
printf("TEAM 1 WINS\n");
return 0;
}
if (cnt < 0) {
printf("TEAM 2 WINS\n");
return 0;
}
printf("TIE\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int weight[100005];
class edge {
public:
int left, right, weight;
edge();
edge(int l, int r, int w) : left(l), right(r), weight(w){};
bool operator<(const edge &a) const { return this->weight > a.weight; }
};
class union_find {
public:
vector<double> parent, rank;
union_find() {}
union_find(int n) : parent(n + 1), rank(n + 1, 1) {
for (int i = 1; i <= n; i++) parent[i] = i;
}
int find(int a) {
if (parent[a] == a) return a;
return parent[a] = find(parent[a]);
}
void merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (rank[a] < rank[b]) swap(a, b);
parent[b] = a;
rank[a] += rank[b];
}
double printRank(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return 0;
return rank[a] * rank[b];
}
};
vector<edge> e;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &weight[i]);
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
e.push_back(edge(a, b, min(weight[a], weight[b])));
}
sort(e.begin(), e.end());
union_find uf(n);
double res = 0;
for (int i = 0; i < e.size(); i++) {
int a = e[i].left, b = e[i].right;
int w = e[i].weight;
res += uf.printRank(a, b) * (double)w;
uf.merge(a, b);
}
printf("%lf\n", (res * 2) / ((double)(n) * (double)(n - 1)));
}
| 4 |
#include <bits/stdc++.h>
const int mod = 1000000007;
const int maxn = 1000005;
int n;
int prime[maxn], minpf[maxn], minpfpw[maxn], tot = 0;
bool flag[maxn];
int ind[maxn], ind2[maxn];
int cnt[maxn];
int fac[maxn];
int a[maxn];
int ans = 1;
int pos[maxn], pos2[maxn], maxpf[maxn];
void work() {
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = fac[i - 1] * 1ll * i % mod;
minpf[1] = minpfpw[1] = 1;
for (int i = 2; i <= n; ++i) {
if (!flag[i]) {
prime[++tot] = i;
minpf[i] = minpfpw[i] = i;
}
for (int j = 1; j <= tot && prime[j] * i <= n; ++j) {
flag[prime[j] * i] = true;
minpf[prime[j] * i] = prime[j];
if (i % prime[j] == 0) {
minpfpw[prime[j] * i] = minpfpw[i] * prime[j];
break;
} else
minpfpw[prime[j] * i] = prime[j];
}
}
ind[1] = 1;
for (int i = 2; i <= n; ++i) {
ind[i] = ind[i / minpfpw[i]] * minpf[i];
}
ind2[1] = 1;
for (int i = 1, old = 1; i <= tot; ++i) {
if (n / prime[i] != n / old) old = prime[i];
ind2[prime[i]] = old;
if (prime[i] * 2 > n) ind2[prime[i]] = 1;
}
for (int i = 1; i <= n; ++i) {
if (flag[i]) {
ind2[i] = ind2[i / minpfpw[i]] * ind2[minpf[i]];
}
}
for (int i = 1; i <= n; ++i)
if (a[i] && ind2[a[i]] != ind2[i]) {
ans = 0;
return;
};
for (int i = 1; i <= n; ++i) {
if (!a[i]) cnt[ind[i]]++;
}
for (int i = 1; i <= n; ++i) ans = ans * 1ll * fac[cnt[i]] % mod;
memset(cnt, 0, sizeof(cnt));
maxpf[1] = 1;
for (int i = 2; i <= n; ++i) {
if (i == minpfpw[i])
maxpf[i] = minpf[i];
else
maxpf[i] = maxpf[i / minpfpw[i]];
}
for (int i = 1; i <= n; ++i) {
if (a[i] == 0) continue;
int u = maxpf[i], v = maxpf[a[i]];
if (pos[u] && pos[u] != v) {
ans = 0;
return;
};
pos[u] = v;
if (pos2[v] && pos2[v] != u) {
ans = 0;
return;
};
pos2[v] = u;
}
for (int i = 1; i <= n; ++i) {
if (!flag[i] && !pos[i]) {
cnt[ind2[i]]++;
}
}
for (int i = 1; i <= n; ++i) ans = ans * 1ll * fac[cnt[i]] % mod;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
work();
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int tot[100000];
int cnt = 0;
for (int i = 0; i <= 100; i++) {
for (int j = 0; j <= 100; j++) {
tot[cnt++] = 3 * i + 7 * j;
}
}
while (n--) {
int a;
cin >> a;
int flag = 0;
for (int i = 0; i < cnt; i++) {
if (a == tot[i]) flag = 1;
}
if (flag == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int counter = 0;
int main() {
int a[3][4];
for (int i = 1; i <= 2; i++)
for (int j = 1; j <= 3; ++j) cin >> a[i][j];
for (int i = 1; i <= 3; i++)
if (a[1][i] == a[2][i]) counter++;
if (counter >= 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, x, b, y, sum, i, j;
bool flag = false;
scanf("%d %d %d %d %d", &n, &a, &x, &b, &y);
j = b;
for (i = a; i != x && j != y;) {
if (i < n)
i++;
else
i = 1;
if (j > 1)
j--;
else
j = n;
if (i == j) {
flag = true;
break;
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m, cnt, fa[maxn], sum[maxn], dep[maxn], top[maxn], son[maxn], size[maxn],
tid[maxn << 1], head[maxn], nxt[maxn << 1], to[maxn << 1];
void addline(int u, int v) { nxt[++cnt] = head[u], head[u] = cnt, to[cnt] = v; }
int dfs1(int u, int f) {
size[u] = 1, fa[u] = f, dep[u] = dep[f] + 1;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v != f) {
tid[i] = v, size[u] += dfs1(v, u);
if (size[v] > size[son[u]]) son[u] = v;
}
}
return size[u];
}
void dfs2(int u, int tp) {
top[u] = tp;
if (son[u]) dfs2(son[u], tp);
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v != fa[u] && v != son[u]) dfs2(v, v);
}
}
int get_sum(int u) {
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v != fa[u]) sum[u] += get_sum(v);
}
return sum[u];
}
int lca(int u, int v) {
while (top[u] != top[v]) {
if (dep[top[u]] > dep[top[v]]) {
u = fa[top[u]];
} else {
v = fa[top[v]];
}
}
return dep[u] > dep[v] ? v : u;
}
int main() {
int u, v;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
addline(u, v), addline(v, u);
}
dfs1(1, 0), dfs2(1, 1);
scanf("%d", &m);
while (m--) {
scanf("%d %d", &u, &v);
sum[u]++, sum[v]++, sum[lca(u, v)] -= 2;
}
get_sum(1);
for (int i = 1; i <= cnt; i++) {
if (tid[i]) printf("%d ", sum[tid[i]]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int acc1[100009];
int acc2[100009];
vector<pair<int, int> > v1, v2;
int n1, n2;
int main() {
int n, v, a, b;
scanf("%d%d", &n, &v);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
if (a == 1)
v1.push_back(make_pair(b, i + 1));
else
v2.push_back(make_pair(b, i + 1));
}
n1 = v1.size();
n2 = v2.size();
sort(v1.rbegin(), v1.rend());
for (int i = 0; i < n1; i++) acc1[i + 1] = acc1[i] + v1[i].first;
sort(v2.rbegin(), v2.rend());
for (int i = 0; i < n2; i++) acc2[i + 1] = acc2[i] + v2[i].first;
int ret = 0, ind = 0;
for (int os = 0; os <= min(n1, v); os++) {
int rem = min((v - os) / 2, n2);
int temp = acc1[os] + acc2[rem];
if (temp > ret) {
ret = temp;
ind = os;
}
}
cout << ret << endl;
int rem = min((v - ind) / 2, n2);
string s2 = "";
for (int i = 0; i < ind; i++) {
cout << s2 << v1[i].second;
s2 = " ";
}
for (int i = 0; i < rem; i++) {
cout << s2 << v2[i].second;
s2 = " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c2 = 0, c3 = 0;
cin >> n >> m;
if (n == m)
cout << "0" << endl;
else if (m % n != 0)
cout << "-1" << endl;
else {
m /= n;
while (m > 1) {
if (m % 2 == 0) {
c2++;
m /= 2;
} else
break;
}
while (m > 1) {
if (m % 3 == 0) {
c3++;
m /= 3;
} else
break;
}
if (m != 1)
cout << "-1" << endl;
else
cout << c2 + c3 << endl;
}
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main() {
int n, a, b;
int p[100002] = {};
int res = 0;
cin >> n;
for (int i=0; i<n; i++) {
cin >> a >> b;
p[a]++;
p[b+1]--;
}
for (int i=1; i<100002; i++) {
p[i] += p[i-1];
}
res = 1;
for (int i=1; i<100002; i++) {
if (p[i] >= i-1) {
res = i;
}
}
res--;
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int s, f, t;
cin >> s >> f >> t;
int x = t % (2 * (m - 1));
int y = t - x;
int ans = 0;
if (s == f) {
ans = t;
} else if (s < f) {
if (x <= s - 1) {
ans = y + f - 1;
} else {
ans = y + 2 * (m - 1) + f - 1;
}
} else {
if (x <= (m - 1) + (m - s)) {
ans = y + (m - 1) + m - f;
} else {
ans = y + 3 * (m - 1) + m - f;
}
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, l, k, a[210], p[210];
bool u[210][210][410];
double d[210][210][410];
double go(int pos, int won, int freeplace) {
freeplace = min(freeplace, 200);
if (pos == n) {
return won >= l && freeplace >= 0 ? 1.0 : 0.0;
}
if (u[pos][won][freeplace + 200]) {
return d[pos][won][freeplace + 200];
}
double res = 0.0;
res += p[pos] * 0.01 * go(pos + 1, won + 1, freeplace + a[pos]);
res += (1.0 - p[pos] * 0.01) * go(pos + 1, won, freeplace);
u[pos][won][freeplace + 200] = true;
return d[pos][won][freeplace + 200] = res;
}
int main() {
scanf("%d %d %d", &n, &l, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
printf("%.10f\n", go(0, 0, k));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double sy, a, b;
double fencel[200005];
double fencer[200005];
double pre[200005];
int main() {
scanf("%lf%lf%lf", &sy, &a, &b);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &fencel[i], &fencer[i]);
pre[i + 1] = pre[i] + (fencer[i] - fencel[i]);
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
double x, y;
scanf("%lf%lf", &x, &y);
double sfb = (y - 0) / (y - sy);
double pax = a - x;
double pbx = b - x;
pax = pax * sfb;
pbx = pbx * sfb;
pax = x + pax;
pbx = x + pbx;
if (pbx <= fencel[0]) {
printf("0.000000000000000\n");
continue;
}
if (pax >= fencer[n - 1]) {
printf("0.000000000000000\n");
continue;
}
int l = 0, r = n - 1, mid;
while (l <= r) {
mid = (l + r) / 2;
if (fencer[mid] > pax + 1e-8)
r = mid - 1;
else
l = mid + 1;
}
l = r + 1;
double left = pre[l + 1];
left -= min(fencer[l] - fencel[l], (fencer[l] - pax));
l = 0, r = n - 1;
while (l <= r) {
mid = (l + r) / 2;
if (fencel[mid] < pbx - 1e-8)
l = mid + 1;
else
r = mid - 1;
}
r = l - 1;
double right = pre[n] - pre[r];
right -= min(fencer[r] - fencel[r], pbx - fencel[r]);
double time = (b - a) * (pre[n] - right - left) / (pbx - pax);
printf("%.15f\n", time);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, dist[111];
int next(int src) {
if (src == n)
return 1;
else
return src + 1;
}
int get(int s, int t) {
int res = 0, cur = s;
while (1) {
if (cur == t) break;
res += dist[cur];
cur = next(cur);
}
return res;
}
int main(void) {
int s, t;
cin >> n;
for (int i = 1; i <= n; i++) cin >> dist[i];
cin >> s >> t;
int d1 = get(s, t);
int d2 = get(t, s);
cout << min(d1, d2) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool get_int(T &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-' && t != EOF; t = getchar())
;
if (t == '-') neg = true, t = getchar();
if (t == EOF) return false;
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
return true;
}
template <typename T>
void print_int(T x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const double pi = acos(-1.0);
const int maxn = 100111;
int n, k, a[maxn], cnt[maxn];
vector<int> dv[maxn];
int main() {
(get_int(n) && get_int(k));
for (int i = 1; i <= n; i++) get_int(a[i]);
for (int i = 2; i < maxn; i++)
if ((int)dv[i].size() == 0) {
for (int j = i; j < maxn; j += i) dv[j].push_back(i);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long need = 1, is = 1;
for (auto v : dv[a[i]]) {
int cnt = 0, tmp = a[i];
while (tmp % v == 0) {
cnt++;
tmp /= v;
}
cnt %= k;
for (int j = 0; j < cnt; j++) is *= v;
if (k > 40)
need = maxn - 1;
else if (cnt) {
for (int j = 0; j < k - cnt; j++) need = min(maxn - 1ll, need * v);
}
}
ans += cnt[need];
cnt[is]++;
}
print_int(ans), puts("");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 500;
const long long mod = 1e9 + 7;
const long long INF = 1LL << 57;
const int M = 1e6 + 500;
const long long int ths = 1LL << 40;
void solve() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int c1 = 0, c2 = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'z') c1++;
if (s[i] == 'n') c2++;
}
long long int cnt = 0;
for (int i = 1; i <= c2; i++) {
cout << 1 << ' ';
}
for (int i = 0; i < c1; i++) cout << 0 << ' ';
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
string s;
for (int _ = 0; _ < (int)(n); _++) {
cin >> s;
int len = s.size() - 4;
int t = atoi(s.substr(4).c_str());
int k = 10;
int wow = 0;
for (int p = 1; p < len; p++) {
wow += k;
k *= 10;
}
while (t < 1989 + wow) {
t += k;
}
cout << t << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int a, x, y;
cin >> a >> x >> y;
if (y % a == 0) {
cout << "-1";
return 0;
}
int h = a / 2;
if (a % 2 == 0) h--;
if (y <= 2 * a) {
if (-h <= x && x <= h) {
if (y > a)
cout << "2";
else
cout << "1";
} else {
cout << "-1";
}
return 0;
}
int l = (y - 2 * a) / a;
if (l % 2 == 0) {
if (x == 0) {
cout << "-1";
return 0;
}
if (!(-a < x && x < a)) {
cout << "-1";
return 0;
}
int below = 2 + l + (l + 1) / 2;
if (x < 0)
cout << below + 1 << "\n";
else
cout << below + 2 << "\n";
} else {
if (!(-h <= x && x <= h)) {
cout << "-1";
return 0;
}
int below = 2 + l + (l + 1) / 2;
cout << below + 1 << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, u, v;
int val[2000010];
pair<int, int> l[2000010];
int fa[2000010];
bool spe[2000010];
int maxv[2000010], secv[2000010];
int c[5];
int get_fa(int x) {
if (fa[x] == 0) return x;
fa[x] = get_fa(fa[x]);
return fa[x];
}
bool merge(int u, int v) {
u = get_fa(u);
v = get_fa(v);
if (u == v) {
if (spe[u] == 1) return 0;
spe[u] = 1;
} else {
fa[u] = v;
spe[v] = max(spe[v], spe[u]);
c[0] = maxv[v];
c[1] = maxv[u];
c[2] = secv[v];
c[3] = secv[u];
sort(c, c + 4);
maxv[v] = c[3];
secv[v] = c[2];
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &u, &v);
l[i] = make_pair(u, v);
val[i * 2] = u;
val[i * 2 - 1] = v;
}
sort(val + 1, val + 1 + 2 * n);
int cnt = unique(val + 1, val + 1 + 2 * n) - val - 1;
for (int i = 1; i <= n; i++) {
l[i].first = lower_bound(val + 1, val + 1 + cnt, l[i].first) - val;
l[i].second = lower_bound(val + 1, val + 1 + cnt, l[i].second) - val;
}
for (int i = 1; i <= cnt; i++) {
maxv[i] = val[i];
secv[i] = 0;
}
for (int i = 1; i <= n; i++) {
if (merge(l[i].first, l[i].second) == 0) {
printf("-1");
return 0;
}
}
int ans = 0;
for (int i = 1; i <= cnt; i++)
if (i == get_fa(i)) {
if (spe[i] == 1)
ans = max(ans, maxv[i]);
else
ans = max(ans, secv[i]);
}
printf("%d", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int pa[400005];
int find(int x) { return !pa[x] ? x : pa[x] = find(pa[x]); }
bool uni(int x, int y) {
int i = find(x), j = find(y);
if (i == j)
return false;
else {
pa[i] = j;
}
return true;
}
int a[400005];
bool b[400005];
int main() {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
memset(pa, 0, sizeof(pa));
ios::sync_with_stdio(false);
int n;
cin >> n;
int root = 0;
int cnt = 0;
int cir = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] == i) {
if (!root)
root = i;
else
b[i] = true, cnt++;
} else {
if (!uni(i, a[i])) {
cir = i;
b[i] = true, cnt++;
}
}
}
cout << cnt << endl;
if (!root && cir) root = cir;
for (int i = 1; i <= n; ++i) {
if (b[i])
cout << root << " ";
else
cout << a[i] << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
double vp, vd, t, f, c;
cin >> vp >> vd >> t >> f >> c;
if (vp > vd) {
cout << "0" << endl;
return 0;
}
double i = vp * t;
double baki = c - i;
int cnt = 0;
while (1) {
double temp = i / (vd - vp);
double d = vd * temp;
double p = vp * temp + i;
if (-p + c < 0.000000001 || c - p == 0 || p >= c) break;
baki -= d;
i = p + f * vp + temp * vp;
cnt++;
}
cout << cnt << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int read() {
char ch;
bool flag = 0;
int res;
while (!isdigit(
ch = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++)))
(ch == '-') && (flag = true);
for (res = ch - '0'; isdigit(
ch = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin),
p1 == p2)
? EOF
: *p1++));
res = res * 10 + ch - '0')
;
(flag) && (res = -res);
return res;
}
const int N = 100005;
int q[N], h, t, n, m, p, r;
long long dp[2][N], c[N], d[N], sum[N];
inline double slope(int j, int k) {
return (dp[r ^ 1][j] + sum[j] - dp[r ^ 1][k] - sum[k]) * 1.0 / (j - k);
}
int main() {
n = read(), m = read(), p = read();
for (int i = 2; i <= n; ++i) d[i] = read() + d[i - 1];
for (int i = 1; i <= m; ++i) {
int h = read(), t = read();
c[i] = t - d[h];
}
sort(c + 1, c + 1 + m);
for (int i = 1; i <= m; ++i) sum[i] = sum[i - 1] + c[i];
for (int i = 1; i <= m; ++i) dp[1][i] = c[i] * (i - 1) - sum[i - 1];
for (int i = 2; i <= p; ++i) {
r = i & 1;
h = t = 0;
for (int i = 1; i <= m; ++i) {
while (h < t && slope(q[h], q[h + 1]) < c[i]) ++h;
dp[r][i] = dp[r ^ 1][q[h]] + c[i] * (i - q[h]) - sum[i] + sum[q[h]];
while (h < t && slope(q[t], q[t - 1]) > slope(q[t], i)) --t;
q[++t] = i;
}
}
printf("%lld\n", dp[p & 1][m]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
using namespace std;
inline long long in() {
long long x;
scanf("%lld", &x);
return x;
}
long long n;
const long long N = 1e5 + 4;
long long a[N];
long long mn[N];
int32_t main() {
n = in();
for (long long i = 0; i < n; i++) a[i] = in();
mn[n - 1] = a[n - 1];
for (long long i = n - 2; i >= 0; i--) mn[i] = min(a[i], mn[i + 1]);
long long ans;
for (long long i = 0; i < n; i++) {
ans = lower_bound(mn + i, mn + n, a[i]) - mn - 1 - i;
ans--;
cout << max(ans, -1LL) << " ";
}
}
| 2 |
#include<bits/stdc++.h>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define EPS (1e-7)
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
#define equals(a,b) (fabs((a)-(b)) < EPS)
using namespace std;
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);}
Point operator * (Point a){ return Point(x * a.x - y * a.y, x * a.y + y * a.x); }
bool operator < (const Point& p) const{ return !equals(x,p.x)?x<p.x:(!equals(y,p.y)&&y<p.y); }
bool operator == (const Point& p)const{ return fabs(x-p.x) < EPS && fabs(y-p.y) < EPS; }
};
struct Segment{
Point p1,p2;
Segment(Point p1 = Point(),Point p2 = Point()):p1(p1),p2(p2){}
bool operator == (const Segment& p)const { return ( p.p1 == p1 && p.p2 == p2 ) || ( p.p1 == p2 && p.p2 == p1 ); }
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;
ostream& operator << (ostream& os,const Point& a){ os << "(" << a.x << "," << a.y << ")"; }
ostream& operator << (ostream& os,const Segment& a){ os << "( " << a.p1 << " , " << a.p2 << " )"; }
double dot(Point a,Point b){ return a.x*b.x + a.y*b.y; }
double cross(Point a,Point b){ return a.x*b.y - a.y*b.x; }
double norm(Point a){ return a.x*a.x+a.y*a.y; }
double abs(Point a){ return sqrt(norm(a)); }
//rad は角度をラジアンで持たせること
Point rotate(Point a,double rad){ return Point(cos(rad)*a.x - sin(rad)*a.y,sin(rad)*a.x + cos(rad)*a.y); }
// 度をラジアンに変換
double toRad(double agl){ return agl*M_PI/180.0; }
// a => prev, b => cur, c=> next
// prev から cur へ行って next へ行く際の角度を求める
double getArg(Point a,Point b,Point c){
double arg1 = atan2(b.y-a.y,b.x-a.x);
double arg2 = atan2(c.y-b.y,c.x-b.x);
double arg = fabs( arg1 - arg2 );
while( arg > M_PI ) arg -= 2.0 * M_PI;
return fabs(arg);
}
int ccw(Point p0,Point p1,Point p2){
Point a = p1-p0;
Point 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(norm(a) < norm(b))return ONLINE_FRONT;
return ON_SEGMENT;
}
bool intersectLL(Line l, Line m) {
return abs(cross(l.p2-l.p1, m.p2-m.p1)) > EPS || // non-parallel
abs(cross(l.p2-l.p1, m.p1-l.p1)) < EPS; // same line
}
bool intersectLS(Line l, Line s) {
return cross(l.p2-l.p1, s.p1-l.p1)* // s[0] is left of l
cross(l.p2-l.p1, s.p2-l.p1) < EPS; // s[1] is right of l
}
bool intersectLP(Line l,Point p) {
return abs(cross(l.p2-p, l.p1-p)) < EPS;
}
bool intersectSS(Line s, Line t) {
return ccw(s.p1,s.p2,t.p1)*ccw(s.p1,s.p2,t.p2) <= 0 &&
ccw(t.p1,t.p2,s.p1)*ccw(t.p1,t.p2,s.p2) <= 0;
}
bool intersectSP(Line s, Point p) {
return abs(s.p1-p)+abs(s.p2-p)-abs(s.p2-s.p1) < EPS; // triangle inequality
}
Point projection(Line l,Point p) {
double t = dot(p-l.p1, l.p1-l.p2) / norm(l.p1-l.p2);
return l.p1 + (l.p1-l.p2)*t;
}
Point reflection(Line l,Point p) {
return p + (projection(l, p) - p) * 2;
}
double distanceLP(Line l, Point p) {
return abs(p - projection(l, p));
}
double distanceLL(Line l, Line m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m.p1);
}
double distanceLS(Line l, Line s) {
if (intersectLS(l, s)) return 0;
return min(distanceLP(l, s.p1), distanceLP(l, s.p2));
}
double distanceSP(Line s, Point p) {
Point r = projection(s, p);
if (intersectSP(s, r)) return abs(r - p);
return min(abs(s.p1 - p), abs(s.p2 - p));
}
double distanceSS(Line s, Line t) {
if (intersectSS(s, t)) return 0;
return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}
Point crosspoint(Line l,Line m){
double A = cross(l.p2-l.p1,m.p2-m.p1);
double B = cross(l.p2-l.p1,l.p2-m.p1);
if(abs(A) < EPS && abs(B) < EPS){
vector<Point> vec;
vec.push_back(l.p1),vec.push_back(l.p2),vec.push_back(m.p1),vec.push_back(m.p2);
sort(vec.begin(),vec.end());
assert(vec[1] == vec[2]); //同じセグメントかもよ
return vec[1];
//return m.p1;
}
if(abs(A) < EPS)assert(false);
return m.p1 + (m.p2-m.p1)*(B/A);
}
//cross product of pq and pr
double cross3p(Point p,Point q,Point r)
{
return (r.x-q.x) * (p.y -q.y) - (r.y - q.y) * (p.x - q.x);
}
//returns true if point r is on the same line as the line pq
bool collinear(Point p,Point q,Point r)
{
return fabs(cross3p(p,q,r)) < EPS;
}
//returns true if point t is on the left side of line pq
bool ccwtest(Point p,Point q,Point r)
{
return cross3p(p,q,r) > 0;//can be modified to accept collinear points
}
bool onSegment(Point p,Point q,Point r){
return collinear(p,q,r) && equals(sqrt(pow(p.x-r.x,2)+pow(p.y-r.y,2)) + sqrt(pow(r.x-q.x,2) + pow(r.y-q.y,2) ),sqrt(pow(p.x-q.x,2)+pow(p.y-q.y,2)) ) ;
}
double getArea(vector<Point>& vec){
double sum = 0;
for(int i=0;i<(int)vec.size();i++) sum += cross(vec[i],vec[(i+1)%vec.size()]);
return fabs(sum)/2.0;
}
bool DEBUG = false;
int N;
vector<Point> ps;
bool comp_dist(const Point& a,const Point& b) { return abs(a) < abs(b); }
void makeSegments(vector<Segment> &segs){
//int dex = 0;
vector<Point> vp;
rep(i,N-1) {
vp.clear();
vp.push_back(ps[i]);
vp.push_back(ps[i+1]);
Segment cur_seg = Segment(ps[i],ps[i+1]);
rep(j,N-1) if( i != j ) {
Segment seg = Segment(ps[j],ps[j+1]);
if( equals(cross(cur_seg.p1-cur_seg.p2,seg.p1-seg.p2),0.0) ) {
if( onSegment(cur_seg.p1,cur_seg.p2,seg.p1) ) {
vp.push_back(seg.p1);
}
if( onSegment(cur_seg.p1,cur_seg.p2,seg.p2) ) {
vp.push_back(seg.p2);
}
} else if( intersectSS(seg,cur_seg) ) {
vp.push_back(crosspoint(cur_seg,seg));
}
rep(k,vp.size()) vp[k] = vp[k] - ps[i];
sort(vp.begin(),vp.end(),comp_dist);
vp.erase(unique(vp.begin(),vp.end()),vp.end());
rep(k,vp.size()) vp[k] = vp[k] + ps[i];
}
rep(k,vp.size()) vp[k] = vp[k] - ps[i];
sort(vp.begin(),vp.end(),comp_dist);
vp.erase(unique(vp.begin(),vp.end()),vp.end());
rep(k,vp.size()) vp[k] = vp[k] + ps[i];
rep(j,(int)vp.size()-1) {
segs.push_back(Segment(vp[j],vp[j+1]));
//segs[dex++] = Segment(vp[j],vp[j+1]);
}
}
//segs.resize(dex);
}
vector<Point> angle_ps;
struct Data{
int from,to,rev;
bool operator < (const Data & a)const{
//cout << from << "," << to << " " << a.from << "," << a.to<< endl;
int tmp = max(from,to);
int tmp2 = max(a.from,a.to);
tmp = max(tmp,tmp2);
//if( tmp >= angle_ps.size() ) return false;
Vector vec_a = angle_ps[a.to] - angle_ps[a.from];
Vector vec_b = angle_ps[to] - angle_ps[from];
double arg_a = atan2(vec_b.y,vec_b.x);
double arg_b = atan2(vec_a.y,vec_a.x);
return !equals(arg_a,arg_b) && arg_a < arg_b;
}
};
/*
bool comp_angle(const Data& a,const Data& b){
cout << a.from << "," << a.to << " " << b.from << "," << b.to << endl;
Vector vec_a = angle_ps[a.to] - angle_ps[a.from];
Vector vec_b = angle_ps[b.to] - angle_ps[b.from];
return atan2(vec_a.y,vec_a.x) <= atan2(vec_b.y,vec_b.x);
}*/
vector<vector<Data> > G;
vector<Point> vp;
void makeGraph(const vector<Segment> &segs){
map<Point,int> mp;
int V = 0;
rep(i,segs.size()) if( !mp.count(segs[i].p1) ) mp[segs[i].p1] = V++;
if( !mp.count(segs.back().p2) ) mp[segs.back().p2] = V++;
vp.resize(V);
for(map<Point,int>::iterator it = mp.begin(); it != mp.end(); it++){
vp[it->second] = it->first;
}
angle_ps = vp;
G.resize(V,vector<Data>());
rep(i,segs.size()) {
int s = mp[segs[i].p1], t = mp[segs[i].p2];
G[s].push_back((Data){s,t,-1});
G[t].push_back((Data){t,s,-1});
}
rep(i,V) {
sort(G[i].begin(),G[i].end());
}
rep(i,V) rep(j,(int)G[i].size()) if( G[i][j].rev == -1 ) {
int to = G[i][j].to;
rep(k,(int)G[to].size())if( G[to][k].to == i ){
G[i][j].rev = k;
G[to][k].rev = j;
break;
}
}
}
const int MAX_V = 6000;
bool visited[MAX_V][MAX_V];
bool getPath(int start_node,int node,int edge,vector<Point> &buf){
if( visited[node][edge] ){
if( !buf.empty() && node == start_node ) return true;
return false;
}
visited[node][edge] = true;
int next_node = G[node][edge].to;
int next_edge = (G[node][edge].rev+1)%((int)G[next_node].size());
buf.push_back(vp[G[node][edge].from]);
if(getPath(start_node,next_node,next_edge,buf)) return true;
else return visited[node][edge] = false;
}
void compute(){
vector<Segment> segs;
segs.clear();
makeSegments(segs);
makeGraph(segs);
segs.clear();
ps.clear();
angle_ps.clear();
int V = vp.size();
assert( V < MAX_V );
rep(i,V) rep(j,V) visited[i][j] = false;
double area = 0;
rep(i,V) rep(j,(int)G[i].size()) if( !visited[i][j] ){
vector<Point> buf;
if( getPath(i,i,j,buf) && !buf.empty() ) area += getArea(buf);
}
printf("%.10lf\n",area/2.0);
}
int main(){
cin >> N;
ps.resize(N);
rep(i,N) cin >> ps[i].x >> ps[i].y;
if( N == 43) {
bool ok = true;
Point test[43] = {
Point(720,400),
Point(380,400),
Point(400,460),
Point(720,400),
Point(400,460),
Point(520,560),
Point(720,400),
Point(520,560),
Point(600,580),
Point(720,400),
Point(600,580),
Point(820,580),
Point(720,400),
Point(820,580),
Point(920,500),
Point(720,400),
Point(920,500),
Point(960,400),
Point(720,400),
Point(960,400),
Point(960,300),
Point(720,400),
Point(920,240),
Point(860,180),
Point(720,400),
Point(860,180),
Point(720,180),
Point(720,400),
Point(720,180),
Point(600,200),
Point(720,400),
Point(600,200),
Point(520,240),
Point(720,400),
Point(520,240),
Point(480,280),
Point(720,400),
Point(480,280),
Point(420,320),
Point(720,400),
Point(420,320),
Point(380,400),
Point(720,400)
};
rep(i,N) if( !( test[i] == ps[i] ) ) ok = false;
if( ok ) DEBUG = true;
}
compute();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k[15], dif[15];
char s[15][40];
string tmp = "0000000000000000000000000000000000000000";
map<string, int> mp;
void dfs(int p, char c) {
if (p == n + 1) {
for (int i = 1; i <= m; ++i)
if (dif[i] != k[i]) return;
mp[tmp] = 1;
return;
}
if (c == '1') tmp[p] = '1';
for (int i = 1; i <= m; ++i) {
if (tmp[p] != s[i][p]) {
dif[i]++;
if (dif[i] > k[i]) {
for (int j = 1; j <= i; ++j) {
if (tmp[p] != s[j][p]) dif[j]--;
}
if (c == '1') tmp[p] = '0';
return;
}
}
}
dfs(p + 1, '0');
dfs(p + 1, '1');
for (int i = 1; i <= m; ++i) {
if (tmp[p] != s[i][p]) dif[i]--;
}
if (c == '1') tmp[p] = '0';
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) scanf("%s%d", s[i] + 1, &k[i]);
dfs(1, '0');
dfs(1, '1');
printf("%d", (int)mp.size());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 4, oo = 1e9 + 7;
int m, n;
pair<int, int> a[N];
struct Interval_Tree {
int node[4 * N], lazy[4 * N];
void Build(int i, int l, int r) {
node[i] = lazy[i] = oo;
if (l == r) return;
int mid = (l + r) / 2;
Build(2 * i, l, mid);
Build(2 * i + 1, mid + 1, r);
}
void Down(int i) {
node[2 * i] = min(node[2 * i], lazy[i]);
node[2 * i + 1] = min(node[2 * i + 1], lazy[i]);
lazy[2 * i] = min(lazy[2 * i], lazy[i]);
lazy[2 * i + 1] = min(lazy[2 * i + 1], lazy[i]);
lazy[i] = oo;
}
void update(int i, int l, int r, int x, int y, int val) {
if (l > y || x > r) return;
if (x <= l && r <= y) {
node[i] = min(node[i], val);
lazy[i] = min(lazy[i], val);
return;
}
Down(i);
int mid = (l + r) / 2;
update(2 * i, l, mid, x, y, val);
update(2 * i + 1, mid + 1, r, x, y, val);
node[i] = min(node[2 * i], node[2 * i + 1]);
}
int get(int i, int l, int r, int x, int y) {
if (l > y || x > r) return oo;
if (x <= l && r <= y) return node[i];
Down(i);
int mid = (l + r) / 2;
int tmp1 = get(2 * i, l, mid, x, y),
tmp2 = get(2 * i + 1, mid + 1, r, x, y);
return min(tmp1, tmp2);
}
} IT;
void sol() {
IT.Build(1, 0, n);
IT.update(1, 0, n, 0, 0, 0);
sort(a + 1, a + m + 1);
for (int i = 1; i <= (int)m; ++i) {
int x = a[i].first, s = a[i].second;
for (int Add = 0; Add <= (int)n; ++Add) {
int l = max(1, x - s - Add), r = min(x + s + Add, n);
int best = IT.get(1, 0, n, max(l - 1, 0), r) + Add;
IT.update(1, 0, n, l, r, best);
if (l == 1 && r == n) break;
}
}
int res = IT.get(1, 0, n, n, n);
cout << res << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
cin >> m >> n;
for (int i = 1; i <= (int)m; ++i) cin >> a[i].first >> a[i].second;
sol();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> v(51, true);
v[0] = false;
v[1] = false;
for (int i = 2; i <= 50; i++) {
for (int j = i * i; j <= 50; j += i) {
v[j] = false;
}
}
for (int i = n + 1; i <= 50; i++) {
if (v[i] && i == m) {
cout << "YES" << endl;
return 0;
}
if (v[i] && i != m) {
cout << "NO" << endl;
return 0;
}
}
cout << "NO" << endl;
}
| 1 |
#include <stdio.h>
int main() {
int H, W, N;
scanf("%d %d %d", &H, &W, &N);
(H > W) ? printf("%d",(N+H-1)/H) : printf("%d",(N+W-1)/W);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> bb(26, false);
vector<bool> ur(26, false);
vector<bool> id(26, false);
vector<int> v;
string ki = "";
bool im = false;
vector<vector<int> > s(26, v);
void bejar(int x) {
id[x] = bb[x] = true;
for (int i = 0; i < s[x].size(); i++) {
if (id[s[x][i]]) im = true;
if (!bb[s[x][i]]) bejar(s[x][i]);
}
ki += (char)(97 + x);
id[x] = false;
}
int main() {
int n;
cin >> n;
string t[n];
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int o = 0; o < t[i].length(); o++) {
if (o >= t[j].length()) {
cout << "Impossible\n";
return 0;
}
if (t[i][o] < t[j][o]) {
s[(int)t[j][o] - 97].push_back((int)t[i][o] - 97);
break;
} else if (t[i][o] > t[j][o]) {
s[(int)t[j][o] - 97].push_back((int)t[i][o] - 97);
break;
}
}
}
}
for (int i = 0; i < 26; i++) {
if (!bb[i]) {
bejar(i);
id = ur;
}
}
if (im)
cout << "Impossible\n";
else
cout << ki << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int i;
for (i = n; i > n - k; i--) {
cout << i << " ";
}
for (int j = 1; j <= i; j++) {
cout << j << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const double EPS = 1e-9;
const int INT_INF = 0x7FFFFFFF;
const long long I64_INF = 0x7FFFFFFFFFFFFFFF;
const double PI = acos(-1.0);
using namespace std;
int n, k;
int a[100500];
long long sum[100500];
long long getsum(int l, int r) { return sum[r + 1] - sum[l]; }
bool can(int l, int r, int val) {
return 1LL * val * (r - l + 1) - getsum(l, r) <= 1LL * k;
}
int main() {
cin >> n >> k;
sum[0] = 0;
for (int i = 0; i < (int)n; i++) scanf("%d", &a[i]);
sort(a, a + n);
for (int i = 0; i < (int)n; i++) sum[i + 1] = sum[i] + 1LL * a[i];
int ma = 1;
int id = 0;
for (int i = 1; i < (int)n; i++) {
int L = 0;
int R = i;
while (L != R - 1) {
int M = (L + R) / 2;
if (can(M, i - 1, a[i]))
R = M;
else
L = M;
}
if (!can(L, i - 1, a[i])) L++;
if (i - L + 1 > ma) {
ma = i - L + 1;
id = i;
} else if (i - L + 1 == ma && a[i] < a[id])
id = i;
}
printf("%d %d\n", ma, a[id]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Fenwick {
vector<int> t;
int n;
void init(int nn) {
n = nn;
t.assign(n, 0);
}
int sum(int r) {
int result = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) result += t[r];
return result;
}
void inc(int i, int delta) {
for (; i < n; i = (i | (i + 1))) t[i] += delta;
}
int sum(int l, int r) { return sum(r) - sum(l - 1); }
};
const int N = 20000;
const long double PI = acosl(-1.0);
double dist[N];
const double eps = 1e-12;
int x[N];
int y[N];
int r[N];
bool intersect(int i, int R, pair<long double, long double> &ret) {
if (R < dist[i] - r[i] - eps) {
return false;
}
if (R > dist[i] + r[i] + eps) {
return false;
}
double a = -2.0 * x[i];
double b = -2.0 * y[i];
double c = x[i] * x[i] + y[i] * y[i] + R * R - r[i] * r[i];
double x0 = -a * c / (a * a + b * b), y0 = -b * c / (a * a + b * b);
if (abs(c * c - R * R * (a * a + b * b)) < eps) {
double alp = atan2(y0, x0);
ret = make_pair(alp, alp);
} else {
double d = R * R - c * c / (a * a + b * b);
double mult = sqrt(d / (a * a + b * b));
double ax, ay, bx, by;
ax = x0 + b * mult;
bx = x0 - b * mult;
ay = y0 - a * mult;
by = y0 + a * mult;
double alp1 = atan2(ay, ax);
double alp2 = atan2(by, bx);
if (alp1 > alp2) {
swap(alp1, alp2);
}
if (alp2 - alp1 > PI) {
swap(alp1, alp2);
}
ret = make_pair(alp1, alp2);
}
return true;
}
struct event {
long double pos;
int add;
event() {}
event(long double p, int a) : pos(p), add(a) {}
bool operator<(const event &r) const {
if (fabs(pos - r.pos) < eps) {
if (add == 1 && r.add == -1) {
return true;
}
return false;
}
return pos < r.pos;
}
};
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int d;
cin >> d;
double di = 0;
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i] >> r[i];
double cur = sqrt(x[i] * x[i] + y[i] * y[i]);
dist[i] = cur;
}
di = *max_element(dist, dist + n) + 100;
vector<event> e;
for (int i = 0; i < n; ++i) {
for (int j = 1; j * d < di; ++j) {
pair<long double, long double> tmp;
if (intersect(i, j * d, tmp)) {
if (tmp.first > tmp.second + eps) {
e.push_back(event(tmp.first, 1));
e.push_back(event(PI, -1));
e.push_back(event(-PI, 1));
e.push_back(event(tmp.second, -1));
} else {
e.push_back(event(tmp.first, 1));
e.push_back(event(tmp.second, -1));
}
}
}
}
stable_sort(e.begin(), e.end());
int ans = 0;
int cnt = 0;
for (int i = 0; i < (int)e.size(); ++i) {
cnt += e[i].add;
ans = max(ans, cnt);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1;
int n, pr[maxn], nx[maxn], sz;
long long a[maxn], res[maxn];
void Enter() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
}
void Init() {
sort(a + 1, a + n + 1);
sz = res[0] = pr[0] = nx[0] = 0;
}
bool GetBit(long long s, int bit) { return (s >> (bit - 1)) & 1; }
void Connect(int a, int b) {
nx[a] = b;
pr[b] = a;
}
void Try(int bit, int num) {
if (num == 0) {
cout << "Yes\n";
for (int i = nx[0]; i != 0; i = nx[i]) cout << res[i] << ' ';
return;
}
int i = nx[0];
while (num > 0 && GetBit(a[num], bit) && i != 0) {
if (GetBit(res[i], bit)) {
res[++sz] = a[num--];
Connect(pr[i], sz);
Connect(sz, i);
}
i = nx[i];
}
if (num > 0 && GetBit(a[num], bit)) {
res[++sz] = a[num--];
Connect(pr[0], sz);
Connect(sz, 0);
}
if (num > 0 && GetBit(a[num], bit))
cout << "No";
else
Try(bit - 1, num);
}
void Solve() { Try(60, n); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Enter();
Init();
Solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n, m, i, x;
x = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
if (x >= a && x < b) x = b;
}
if (x >= m)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a1, b1, a2, b2, p1, p2, tp1, tp2;
cin >> a1 >> b1 >> a2 >> b2;
p1 = a1 * b1;
p2 = a2 * b2;
int p31 = 0, p32 = 0, ans = 0;
tp1 = p1;
while (tp1 % 3 == 0) p31 += 1, tp1 /= 3;
tp2 = p2;
while (tp2 % 3 == 0) p32 += 1, tp2 /= 3;
ans += abs(p31 - p32);
if (p31 > p32)
while (p31 != p32) {
p31 -= 1;
p1 /= 3;
p1 *= 2;
if (a1 % 3 == 0)
a1 /= 3, a1 *= 2;
else
b1 /= 3, b1 *= 2;
}
else
while (p31 != p32) {
p32 -= 1;
p2 /= 3;
p2 *= 2;
if (a2 % 3 == 0)
a2 /= 3, a2 *= 2;
else
b2 /= 3, b2 *= 2;
}
tp1 = p1;
p31 = 0;
while (tp1 % 2 == 0) p31 += 1, tp1 /= 2;
tp2 = p2;
p32 = 0;
while (tp2 % 2 == 0) p32 += 1, tp2 /= 2;
if (tp1 != tp2) {
cout << -1 << endl;
return 0;
}
ans += abs(p31 - p32);
if (p31 > p32)
while (p31 != p32) {
p31 -= 1;
p1 /= 2;
if (a1 % 2 == 0)
a1 /= 2;
else
b1 /= 2;
}
else
while (p31 != p32) {
p32 -= 1;
p2 /= 2;
if (a2 % 2 == 0)
a2 /= 2;
else
b2 /= 2;
}
cout << ans << endl << a1 << " " << b1 << endl << a2 << " " << b2 << endl;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main() {
int n; cin >> n;
int a[n];
for (int i = 0; i < n; i++)
{
cin >> a[i];
a[i]--;
}
int res = 0;
for (int i = 0; i < n; i++)
{
if(a[a[i]] == i) res++;
}
cout << res / 2 << endl;
return 0;
}
| 0 |
#include<iostream>
#include<cstdio>
#define MN 200000
using namespace std;
inline int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int n,T,a[MN+5],f[MN+5],pos[MN+5];
bool Check(int a,int b,int c){return (a<b&&b<c)||(a<b&&c<a)||(b<c&&c<a);}
int main()
{
n=read();
for(int i=1;i<=n;++i) pos[a[i]=read()]=i;
for(int i=n;i;--i)
if(!T&&i!=n&&pos[i]>pos[i+1]) f[T]=i+1,++T;
else if(T)
{
int F=f[T-1];
if(!Check(pos[F],pos[i],pos[i+1])) f[T]=i+1,++T;
}
cout<<T<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
char a,b,c;
scanf("%c %c %c",&a,&b,&c);
if(a!=b&&a!=c&&b!=c)
printf("Yes");
else
printf("No");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<pair<int, int>> v;
priority_queue<int, vector<int>, greater<int>> pq;
long long int sm = 0;
void add(int x) {
pq.push(x);
sm += x;
if (pq.size() <= k) {
return;
} else {
while (pq.size() > k) {
sm -= pq.top();
pq.pop();
}
}
}
int main() {
cin >> n >> k;
int i, t, b;
for (i = 0; i < n; i++) {
cin >> t >> b;
v.push_back({b, t});
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
long long int ans = 0;
for (i = 0; i < n; i++) {
add(v[i].second);
ans = max(ans, (long long int)(v[i].first) * sm);
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m, t, r, j, tot, s, a[310], b[310];
int main() {
cin >> m >> t >> r;
for (int i = 0; i < m; i++) {
cin >> a[i];
while (a[j] + t < a[i]) {
tot -= b[j++];
}
tot += b[i] = !i ? r : max(0, r - tot + max(0, b[j] - a[j] + a[i] - t));
s += b[i];
}
cout << (r > t ? -1 : s) << endl;
return 0;
}
| 3 |
#include<iostream>
#include<iomanip>
//#include<cstdio>
#include<vector>
#include<map>
#include<queue>
#include<algorithm>
#include<cmath>
#include<cassert>
using namespace std;
typedef long long ll;
const int Nmax = 1e5;
const int P = 1e9+7;
int N, X;
int S[Nmax];
int main(){
cin >> N >> X;
for(int i=0; i<N; i++) cin >> S[i];
sort(S, S+N, greater<int>());
vector<vector<ll> > dp(N+1, vector<ll>(X+1));
dp[0][X] = 1;
for(int i=0; i<N; i++){
for(int j=0; j<=X; j++){
dp[i][j] %= P;
dp[i+1][j%S[i]] += dp[i][j];
dp[i+1][j] += (N-1-i)*dp[i][j]%P;
}
}
ll ans = 0;
for(int j=0; j<=X; j++){
ans = (ans+j*dp[N][j])%P;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
#define MAXN 55
#define EPS 1e-6
#define g 9.8
#define PI acos(-1)
struct Obstacle
{
int l;
int r;
int t;
int b;
} ob[MAXN];
int n,v,tx,ty;
double a,b,c;
void getabc(double angle)
{
double vx = v * cos(angle); //x?方向速度
double vy = v * sin(angle); //y?方向速度
a = -0.5 * g / (vx * vx);
b = vy / vx;
c = 0;
}
bool check1(double x, double up, double down) //是否会撞到障碍物的左（右）?端或者左（右）底端
{
if(x >= tx) //如果障碍物的x坐?在猪的x坐?的右?，?就算会撞到也不要?（?炸??死猪不受?障碍物影?）
return false;
double y = a * x * x + b * x + c; //求出相?的y坐?
if(up <= y && y <= down) //会撞到
return true;
return false;
}
bool check2(double y, double left, double right)
{
double delta = b * b - 4 * a * y;
if(delta < 0) //抛物?与障碍物上（下）的左端和右端形成的?段没有交点，?不会相撞
return false;
delta = sqrt(delta);
double x1 = (-b + delta) / (2 * a);
double x2 = (-b - delta) / (2 * a);
if(x1 < tx && left <= x1 && x1 <= right) //如果抛物?与障碍物上（下）的左端点有交点且交点的x坐?在猪的左?，?无法?死猪
return true;
if(x2 < tx && left <= x2 && x2 <= right) //如果抛物?与障碍物上（下）的右端点有交点且交点的x坐?在猪的左?，?无法?死猪
return true;
return false;
}
bool check3(double x, double y, double h, double t, double l, double r)
{
if(l <= x && x <= r && y <= t && t <= h) //如果障碍正好?在白??行的抛物??迹和猪的中?，?炸蛋无法?中猪
return true;
return false;
}
bool check(double angle)
{
getabc(angle);
double h = a * tx * tx + b * tx + c;
if(h < ty) //?不到猪的上方，?不可能?死猪
return false;
for(int i=0; i<n; i++)
{
if(check1(ob[i].l,ob[i].b,ob[i].t))
return false;
if(check1(ob[i].r,ob[i].b,ob[i].t))
return false;
if(check2(ob[i].b,ob[i].l,ob[i].r))
return false;
if(check2(ob[i].t,ob[i].l,ob[i].r))
return false;
if(check3(tx,ty,h,ob[i].b,ob[i].l,ob[i].r))
return false;
//if(check3(tx,ty,h,ob[i].t,ob[i].l,ob[i].r))
// return false;
}
return true;
}
bool solve()
{
for(double i=0; i<0.5*PI; i+=0.000001)
{
if(check(i))
return true;
}
return false;
}
int main()
{
scanf("%d%d%d%d",&n,&v,&tx,&ty);
for(int i=0; i<n; i++)
scanf("%d%d%d%d",&ob[i].l,&ob[i].b,&ob[i].r,&ob[i].t);
if(solve())
puts("Yes");
else
puts("No");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807;
const int maxn = 100010;
int xors[maxn] = {0};
int grundy[maxn] = {0};
bool mex[maxn] = {0};
int tres[maxn] = {0};
bool calc(int d1, int d2, pair<int, int> &r) {
int b = d1 + d2 - 1;
if (b & 1) return false;
b /= 2;
int a = d1 - b;
if (a >= b) return false;
if (a < 1) return false;
r = make_pair(a, b);
return true;
}
int main() {
int n;
cin >> n;
int tcnt = 0;
int res = -1;
int mincnt = maxn + 100;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j * j <= 2 * i; ++j) {
if ((2 * i) % j == 0) {
int d1 = j, d2 = 2 * i / j;
pair<int, int> temp;
for (int k = 0; k < 2; ++k) {
if (calc(d1, d2, temp)) {
int cx = xors[temp.second] ^ xors[temp.first - 1];
if (i == n && cx == 0 && temp.second - temp.first + 1 < mincnt) {
mincnt = temp.second - temp.first + 1;
}
tres[tcnt++] = cx;
mex[cx] = true;
}
swap(d1, d2);
}
}
}
for (int j = 0;; ++j)
if (!mex[j]) {
grundy[i] = j;
xors[i] = xors[i - 1] ^ grundy[i];
break;
}
for (int j = 0; j < tcnt; ++j) mex[tres[j]] = false;
tcnt = 0;
}
if (mincnt == maxn + 100)
cout << -1;
else
cout << mincnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false);cin.tie(0);
#define int long long
#define endl '\n'
const int mod = 1e9 + 7;
const int inf = 1e18 + 9;
const int N = 1e7 + 5;
bool isPrime[N];
vector<int> primes;
void sieve() {
memset(isPrime, true, sizeof isPrime);
isPrime[1] = false;
for (int i = 2; i * i < N; i++) {
if (isPrime[i]) {
for (int j = 2; i * j < N; j++) {
isPrime[i * j] = false;
}
}
}
for (int i = 1; i < N; i++) {
if (isPrime[i])
primes.push_back(i);
}
}
void solve() {
int d;
cin >> d;
int x = *lower_bound(primes.begin(), primes.end(), d + 1);
int y = *lower_bound(primes.begin(), primes.end(), x + d);
cout << x * y << endl;
}
int32_t main() {
fast;
sieve();
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int lim = 10000000;
int p[lim];
int cont[lim];
int n, k, inp;
int main() {
for (int i = 2; i * i < lim; i++) {
if (!p[i]) {
for (int x = i * i; x < lim; x += i) {
p[x] = 1;
}
}
}
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &inp);
if (inp < lim) cont[inp]++;
}
if (k == 2) {
printf("0\n");
return 0;
}
if (cont[1]) {
printf("1\n");
return 0;
}
if (k >= lim - 10) {
printf("-1\n");
return 0;
}
int ans = 0;
bool ok = true;
for (int i = 2; i < k; i++) {
if (!p[i]) {
if (cont[i])
ans++;
else
ok = false;
}
}
if (ok)
printf("%d\n", ans);
else
printf("-1\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool anagram(char *s1, char *s2) {
long long int count[256];
memset(count, 0, sizeof(count));
long long int i;
for (i = 0; s1[i] && s2[i]; i++) {
count[s1[i]]++;
count[s2[i]]--;
}
if (s1[i] || s2[i]) {
return false;
}
for (long long int i = 0; i < 256; i++) {
if (count[i]) {
return false;
}
}
return true;
}
long long int moduloMultiplication(long long int a, long long int b,
long long int zz) {
long long int res = 0;
a %= 1000000007;
while (b) {
if (b & 1) res = (res + a) % zz;
a = (2 * a) % zz;
b >>= 1;
}
return res;
}
long long int convert(string s) {
bool o = true;
long long int ans = 0;
for (long long int i = 0; i < s.length(); i++) {
ans = ans * 10 + (s[i] - 48);
}
return ans;
}
long long int powmod(long long int a, long long int b, long long int modulo) {
if (b == 0 || a == 1) return 1;
long long int half = powmod(a, (b / 2), modulo) % modulo;
long long int full = (half * half) % modulo;
if (b % 2) return (full * a) % modulo;
return full % modulo;
}
long long int invmod(long long int a, long long int modulo) {
long long int check = powmod(a, modulo - 2, modulo) % modulo;
return check;
}
long long int max(long long int a, long long int b) {
if (a > b) {
return a;
}
return b;
}
long long int min(long long int a, long long int b) {
if (a < b) {
return a;
}
return b;
}
long long int min(long long int a, long long int b, long long int c) {
if (a < b) {
return min(a, c);
} else {
return min(b, c);
}
}
long long int max(long long int a, long long int b, long long int c) {
if (a < b) {
return max(b, c);
} else {
return min(a, c);
}
}
long long int min(long long int a, int b) {
if (a < b) return a;
return b;
}
long long int min(int a, long long int b) {
if (a < b) return a;
return b;
}
long long int max(long long int a, int b) {
if (a > b) return a;
return b;
}
long long int max(int a, long long int b) {
if (a > b) return a;
return b;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a / gcd(a, b) * b;
}
void yes() {
cout << "YES"
<< "\n";
}
void no() {
cout << "NO"
<< "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
long long int n = 0, k = 0, m = 0, ans = 0, flag = 0, temp = 0, f1 = 0,
count = 0, f2 = 0, sum = 0, xx = 0, minn1 = 1e18,
minn2 = 1e18, maxx1 = -1e18, maxx2 = -1e18;
long long int a, b, c;
cin >> a >> b >> c;
ans = 1e18;
long long int A = -1, B = -1, C = -1;
for (long long int i = 1; i <= 2 * a; i++) {
for (long long int j = i; j <= 2 * b; j += i) {
for (long long int hh = 0; hh < 2; hh++) {
long long int gg = j * (c / j) + hh * j;
sum = abs(i - a) + abs(j - b) + abs(gg - c);
if (ans > sum) {
ans = sum;
A = i;
B = j;
C = gg;
}
}
}
}
cout << ans << "\n";
cout << A << " " << B << " " << C << "\n";
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
const int INF=1001001001;
const int INFLL=1001001001001001001ll;
const int mod=1000000007;
inline void add(int &a,int b){
a+=b;
if(a>=mod)a-=mod;
}
int N,M,R;
int A[55],B[55];
vint X[66];
int Y[66];
int dpA[55][55];
int dpB[55][55];
void calc(int n,int a[55],int dp[55][55]){
fill_n(*dp,55*55,0);
n*=2;
for(int i=0;i<n;i++)dp[i][i+1]|=1<<a[i];
bool tmp[55];
for(int len=2;len<=n;len++){
for(int i=0;i+len<=n;i++){
int j=i+len;
for(int r=0;r<R;r++){
memset(tmp,0,sizeof(tmp));
tmp[i]=true;
for(int k=0;k<X[r].size();k++){
for(int l=j;l>=i;l--){
tmp[l]=false;
for(int w=i;w<l;w++){
tmp[l]|=tmp[w]&(dp[w][l]>>X[r][k]&1);
}
}
}
if(tmp[j])dp[i][j]|=1<<Y[r];
}
}
}
}
int dp[33][33];
void solve(){
rep(i,N){
cin>>A[i];
A[i+N]=A[i];
}
rep(i,M){
cin>>B[i];
B[i+M]=B[i];
}
rep(i,R){
X[i].clear();
int k;cin>>k;
X[i].resize(k);
rep(j,k)cin>>X[i][j];
cin>>Y[i];
}
calc(N,A,dpA);
calc(M,B,dpB);
int ans=INT_MIN;
for(int x=0;x<N;x++){
for(int y=0;y<M;y++){
fill_n(*dp,33*33,INT_MIN);
dp[0][0]=0;
for(int i=0;i<N;i++){
for(int j=0;j<M;j++){
for(int ii=1;i+ii<=N;ii++){
for(int jj=1;j+jj<=M;jj++){
if(dpA[x+i][x+i+ii]&dpB[y+j][y+j+jj]){
chmax(dp[i+ii][j+jj],dp[i][j]+1);
}
}
}
}
}
chmax(ans,dp[N][M]);
}
}
if(ans<0)puts("-1");
else printf("%lld\n",ans);
}
signed main(){
while(cin>>N>>M>>R,N||M||R)solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> par[4010];
pair<int, int> ver[4020];
bool f[4010];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < (m); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
par[a].push_back(b);
par[b].push_back(a);
if (a > b) swap(a, b);
ver[i] = make_pair(a, b);
}
for (int i = 0; i < (n); i++) sort(par[i].begin(), par[i].end());
int mi = 1 << 30;
for (int i = 0; i < (m); i++) {
int a = ver[i].first;
int b = ver[i].second;
for (int j = 0; j < (n); j++) {
if (find(par[j].begin(), par[j].end(), a) != par[j].end()) {
if (find(par[j].begin(), par[j].end(), b) != par[j].end()) {
mi =
min(mi, (int)(par[a].size() + par[b].size() + par[j].size() - 6));
}
}
}
}
if (mi == 1 << 30) mi = -1;
cout << mi << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
while (scanf("%d%d%d", &a, &b, &c) != EOF) {
int d = b - a;
if (d == 0) {
printf("YES\n");
} else if (d > 0) {
if (c > 0) {
if (d % c == 0)
printf("YES\n");
else
printf("NO\n");
} else
printf("NO\n");
} else {
if (c < 0) {
if (d % c == 0)
printf("YES\n");
else
printf("NO\n");
} else
printf("NO\n");
}
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define REP(i,a,b) for(int i=(a);i<(b);i++)
#define rep(i,n) REP(i,0,(n))
typedef long long ll;
using namespace std;
int h, w, dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
string s[400];
bool visited[400][400];
ll ans, bk, wt;
void dfs(int sy, int sx, bool isWhite) {
visited[sy][sx] = true;
if (isWhite) wt++;
else bk++;
rep(i, 4) {
int ny = sy + dy[i], nx = sx + dx[i];
if (ny < 0 || ny >= h || nx < 0 || nx >= w || visited[ny][nx]) continue;
if ( isWhite && s[ny][nx] == '#') dfs(ny, nx, false);
if (!isWhite && s[ny][nx] == '.') dfs(ny, nx, true);
}
}
int main() {
cin >> h >> w;
rep(i, h) cin >> s[i];
REP(i, 0, h) {
REP(j, 0, w) {
if (s[i][j] == '#') {
bk = wt = 0;
dfs(i, j, false);
ans += bk * wt;
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<string, string> > p;
string s1, s2;
int i, j, n;
bool t;
cin >> n;
for (i = 1; i <= n; i++) {
t = true;
cin >> s1 >> s2;
for (j = 0; j < p.size(); j++) {
if (p[j].second == s1) {
t = false;
p[j].second = s2;
break;
}
}
if (t) {
p.push_back({s1, s2});
}
}
cout << p.size() << endl;
for (j = 0; j < p.size(); j++)
cout << p[j].first << " " << p[j].second << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int s[1000005];
long long a[1000005];
int head[1000005];
int main() {
memset(s, 0, sizeof(s));
memset(a, 0, sizeof(a));
scanf("%d%d%d", &n, &m, &k);
int tmp;
for (int i = 1; i <= m; i++) {
scanf("%d", &tmp);
s[tmp] = 1;
}
for (int i = 1; i <= k; i++) scanf("%lld", &a[i]);
if (s[0] == 1) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; i++) {
if (s[i])
head[i] = head[i - 1];
else
head[i] = i;
}
long long ans = 0x7fffffffffffffff;
for (int i = 1; i <= k; i++) {
int now = 0;
long long tmp = 1;
while (1) {
if (now + i > n - 1) {
long long ans1 = tmp * a[i];
ans = min(ans, ans1);
break;
}
if (now == head[now + i]) {
break;
}
now = head[now + i];
tmp++;
}
}
if (ans == 0x7fffffffffffffff)
printf("-1\n");
else
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[200005];
bool V[200006] = {0};
int S[200006] = {0};
int n;
long long d = 0, mx = 0;
void dfs(int p) {
V[p] = 1;
d++;
int u = 0;
for (int i = 0; i < G[p].size(); i++) {
int cp = G[p][i];
if (!V[cp]) {
dfs(cp);
u++;
}
}
if (!u) mx = max(mx, d);
d--;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
S[i] = x;
if (x == -1) continue;
G[x].push_back(i);
G[i].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!V[i] && S[i] == -1) {
d = 0;
dfs(i);
}
}
cout << mx;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int f(vector<vector<int> > &e, int u, int d, int l, int r){
int res = 0;
int hight = 10;
for(int i = u; i <= d; i++){
hight = min(hight, e[i][l]);
hight = min(hight, e[i][r]);
}
for(int j = l; j <= r; j++){
hight = min(hight, e[u][j]);
hight = min(hight, e[d][j]);
}
for(int i = u + 1; i < d; i++){
for(int j = l + 1; j < r; j++){
if(hight <= e[i][j]) return 0;
res += hight - e[i][j];
}
}
return res;
}
int main(){
while(1){
int h, w; cin >> h >> w;
if(!h) break;
vector<vector<int> > e(h, vector<int> (w));
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
cin >> e[i][j];
}
}
int ans = 0;
//[u, d]
//[l, r]
for(int u = 0; u < h; u++){
for(int l = 0; l < w; l++){
for(int d = u + 2; d < h; d++){
for(int r = l + 2; r < w; r++){
ans = max(ans, f(e, u, d, l, r));
}
}
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long mM(long long a, long long b, long long mod) {
long long res = 0;
a %= mod;
while (b) {
if (b & 1) res = (res + a) % mod;
a = (2 * a) % mod;
b >>= 1;
}
return res;
}
long long fpow(long long first, long long second, long long p = 1000000007) {
first = first % p;
long long res = 1;
while (second) {
if (second & 1) res = (res * first) % p;
res %= p;
if (res < 0) res = (res + p) % p;
second = second >> 1;
first = (first * first) % p;
if (first < 0) first = (first + p) % p;
first %= p;
}
return res;
}
long long inv(long long n, long long p) { return fpow(n, p - 2, p); }
long long modmul(long long first, long long second, long long p = 1000000007) {
return (first * second) % p;
}
long long modadd(long long first, long long second, long long p = 1000000007) {
if (first >= p) first -= p;
if (second >= p) second -= p;
long long temp = first + second;
if (temp >= p) temp -= p;
if (temp < 0) temp = temp + p;
return temp;
}
int main() {
long long t = 1, tc = 0;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long ans = INT_MIN;
for (int i = 0; i < 8; i++) {
vector<long long> v1, v2;
for (int j = 1; j <= n; j++)
if (j & (1 << i))
v1.push_back(j);
else
v2.push_back(j);
if (v1.size() && v2.size()) {
cout << v1.size() << " " << v2.size() << " ";
for (int i = 0; i < v1.size(); i++) cout << v1[i] << " ";
for (int i = 0; i < v2.size(); i++) cout << v2[i] << " ";
cout << endl;
long long tans;
cin >> tans;
ans = max(ans, tans);
}
}
cout << "-1 " << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("arch=sandybridge")
#pragma GCC target("popcnt")
#pragma comment(linker, "/STACK:16777216")
const long double pi = 3.14159265;
const long long MOD = 1e9 + 7;
const long long INF = LLONG_MAX;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> q(n);
for (long long i = 0; i < n; i++) cin >> q[i];
bool flag = (n % 2 == 0);
for (long long i = 1; i < n; i++) {
if (q[i] <= q[i - 1]) {
flag = true;
}
}
if (flag)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &(n), &(m));
--n, --m;
int l1 = 0, l2 = 0, n1 = n, n2 = m;
while (n1) {
n1 /= 7;
++l1;
}
l1 = max(l1, 1);
while (n2) {
n2 /= 7;
++l2;
}
l2 = max(l2, 1);
if (l1 + l2 > 7) {
printf("0\n");
return 0;
}
int ans = 0;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
int vis[9] = {0};
int a = i, b = j;
for (int(k) = (0); (k) < (l1); (k)++) {
vis[a % 7]++;
a /= 7;
}
for (int(k) = (0); (k) < (l2); (k)++) {
vis[b % 7]++;
b /= 7;
}
int fl = 0;
for (int(k) = (0); (k) < (7); (k)++) {
if (vis[k] > 1) {
fl = 1;
}
}
if (!fl) ++ans;
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, *dp[5001], *sum[5001];
char s[5001];
int fun(int pos, int level) {
if (dp[pos][level]) return dp[pos][level];
if (pos == n) {
dp[pos][level] = 1;
return 1;
}
int ans = 0;
if (s[pos] == 'f')
ans = fun(pos + 1, level + 1);
else
ans = sum[pos + 1][level];
dp[pos][level] = ans;
return ans;
}
int main() {
int i, j;
scanf("%d\n", &n);
for (i = 1; i <= n; i++) {
scanf("%c\n", &s[i]);
dp[i] = (int*)calloc(i + 1, sizeof(int));
sum[i] = (int*)calloc(i + 1, sizeof(int));
}
if (n == 1) {
printf("1\n");
return 0;
}
for (i = n; i >= 1; i--) {
sum[i][0] = fun(i, 0);
for (j = 1; j <= i; j++) {
sum[i][j] = sum[i][j - 1] + fun(i, j);
sum[i][j] %= 1000000007;
}
}
printf("%d\n", dp[1][0]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 5;
const int M = 1e3 + 5;
const int mod = 1e9 + 7;
int n, m, a[N], now, tot;
double dp[2][N * M], sum[N * M], kk, ans = 1;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int main() {
n = read(), m = read();
if (m == 1) return puts("1"), 0;
kk = 1.0 / (m - 1);
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= m; i++)
if (i != a[1]) dp[now][i] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= i * m; j++) sum[j] = sum[j - 1] + dp[now][j];
now ^= 1;
for (int j = 1; j <= i * m; j++) {
dp[now][j] = sum[j - 1];
if (j > m) dp[now][j] -= sum[j - m - 1];
if (j > a[i]) dp[now][j] -= dp[now ^ 1][j - a[i]];
dp[now][j] *= kk;
}
}
for (int i = 1; i <= n; i++) tot += a[i];
for (int i = 1; i < tot; i++) ans += dp[now][i];
printf("%0.10lf\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int h, w, k, x1, yy1, x2, y2, d[4] = {1,-1}, mp[3000005], qu[1000005], b, e, inf=1e9;
int main(){
scanf("%d%d%d", &h, &w, &k); w++;
scanf("%d%d%d%d", &x1, &yy1, &x2, &y2);
memset(mp,-1,sizeof(mp));
for(int i=0; i<h*w; i++) if(getchar() == '.') mp[i+w] = inf;
mp[qu[e++] = x1*w+yy1] = 0;
d[2] = w; d[3] = -w;
while(b<e) for(int i=0, x=qu[b++]; i<4; i++) for(int nx=x+d[i], u=0; u<k && mp[nx]>mp[x]; u++, nx+=d[i]) if(mp[nx] == inf) mp[qu[e++] = nx] = mp[x] + 1;
printf("%d\n", mp[x2*w+y2] == inf ? -1 : mp[x2*w+y2]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long N;
cin >> N;
vector<long long> A(N);
for(int i=0;i<N;i++) cin >> A[i];
map<long long,long long> M;
long long ans=0;
for(int i=0;i<N;i++){
ans += M[i-A[i]];
M[i+A[i]]++;
}
cout << ans << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
inline int read(){
int r=0,f=1;
char c=getchar();
while(c<48||c>57){if(c=='-')f=-1;c=getchar();}
while(c>=48&&c<=57)r=r*10+(c&15),c=getchar();
return r*f;
}
const int N=1e5+10;
int n,m,k,mt,tot;
char a[5];
int c[N*4][27],ed[N*4],d[N],q[N];
bool flag;
vector<int> e[N];
inline void adde(int x,int y){
e[x].push_back(y),++d[y];
}
void dfs(int u,int i){
if(i==k){
if(ed[u]==mt)flag=1;
else adde(mt,ed[u]);
return;
}
if(c[u][26])dfs(c[u][26],i+1);
if(c[u][a[i]-97])dfs(c[u][a[i]-97],i+1);
}
int main(){
n=read(),m=read(),k=read();
for(int i=1;i<=n;++i){
scanf("%s",a);
int u=0;
for(int j=0;j<k;++j){
int ch=a[j]=='_'?26:a[j]-97;
if(!c[u][ch])c[u][ch]=++tot;
u=c[u][ch];
}
ed[u]=i;
}
for(int i=1;i<=m;++i){
scanf("%s",a),mt=read();
flag=0,dfs(0,0);
if(!flag)return puts("NO"),0;
}
int l=1,r=0;
for(int i=1;i<=n;++i)if(!d[i])q[++r]=i;
while(l<=r){
int u=q[l++];
for(int v:e[u])if(!--d[v])q[++r]=v;
}
if(r<n)return puts("NO"),0;
puts("YES");
for(int i=1;i<=n;++i)printf("%d ",q[i]);
}
| 5 |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
while(1) {
string a, str;
cin >> a;
if(a=="#")break;
for(int i=0;i<a.size();i++)
if(a[i] == 'w' || a[i] == 'n' ) str += a[i];
int size = str.size();
int ans = 0;
for(int i=0;i<size;i++)
if(str[i] == 'w') ans += (1<<i)*90;
else ans -= (1<<i)*90;
size--;
if(ans < 0 ) ans = (1<<size)*90+ans;
while(size != 0)
if( ans % 2 == 0 ) ans /= 2,size--;
else break;
if(size == 0) cout << ans << endl;
else cout << ans << "/" << (1<<size) << endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
using namespace std;
#define FOR(i,k,n) for(int i=(k); i<(int)n; ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cout<<*i<<" "; cout<<endl; }
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
string replace(string s, string from, string to){
//cout<<s<<" from:"<<from<<" to:"<<to;
int p = 0;
while(p + from.size() - 1< s.size()){
int loc = s.find(from, p);
if(loc == -1) break;
s = s.replace(loc, from.size(), to);
p = loc + to.size();
}
return s;
}
int dfs(string s, string& g, vector<string>& from, vector<string>& to){
if(s == g) return 0;
if(s.size() > g.size()) return INF;
int res = INF;
REP(i, from.size()){
string t = replace(s, from[i], to[i]);
if(s == t) continue;
int f = dfs(t, g, from, to);
if(f != INF) res = min(res, f + 1);
}
return res;
}
int main(){
int N;
while(cin>>N && N){
vector<string> from(N);
vector<string> to(N);
REP(i,N)cin>>from[i]>>to[i];
string start, goal;
cin>>start>>goal;
int ans = dfs(start, goal, from, to);
if(ans != INF) cout<<ans<<endl;
else cout<<-1<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Rect {
int x1, y1, x2, y2;
long long area() { return (long long)(x2 - x1) * (y2 - y1); }
};
long long intersect(const Rect&, const Rect&);
Rect intersectingRect(const Rect&, const Rect&);
int main() {
Rect white, black1, black2, b1Inside, b2Inside;
long long b1Cover, b2Cover, totalCover;
cin >> white.x1 >> white.y1 >> white.x2 >> white.y2;
cin >> black1.x1 >> black1.y1 >> black1.x2 >> black1.y2;
cin >> black2.x1 >> black2.y1 >> black2.x2 >> black2.y2;
b1Cover = intersect(white, black1);
b2Cover = intersect(white, black2);
b1Inside = intersectingRect(white, black1);
b2Inside = intersectingRect(white, black2);
totalCover = b1Cover + b2Cover - intersect(b1Inside, b2Inside);
if (white.area() - totalCover <= 0)
cout << "NO";
else
cout << "YES";
}
long long intersect(const Rect& rect1, const Rect& rect2) {
long long x = max(0, min(rect1.x2, rect2.x2) - max(rect1.x1, rect2.x1));
long long y = max(0, min(rect1.y2, rect2.y2) - max(rect1.y1, rect2.y1));
return x * y;
}
Rect intersectingRect(const Rect& rect1, const Rect& rect2) {
Rect rect;
if (intersect(rect1, rect2)) {
rect.x1 = max(rect1.x1, rect2.x1);
rect.x2 = min(rect1.x2, rect2.x2);
rect.y1 = max(rect1.y1, rect2.y1);
rect.y2 = min(rect1.y2, rect2.y2);
} else {
rect.x1 = 0;
rect.x2 = 0;
rect.y1 = 0;
rect.y2 = 0;
}
return rect;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
long long n, a[4];
long long pow(long long a, long long b) {
return b ? (pow((a * a) % md, b / 2) * (b % 2 ? a : 1)) % md : 1;
}
int main() {
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
a[0]++;
else if (s[i] == 'C')
a[1]++;
else if (s[i] == 'G')
a[2]++;
else if (s[i] == 'T')
a[3]++;
}
sort(a, a + 4);
swap(a[0], a[3]);
swap(a[1], a[2]);
if (a[0] > a[1]) {
cout << "1" << endl;
} else if (a[1] > a[2]) {
cout << pow(2, n) << endl;
} else if (a[2] > a[3]) {
cout << pow(3, n) << endl;
} else {
cout << pow(4, n) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char c[1005][1005];
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0}, d[1005][1005],
vis[1005][1005];
int main() {
int n, m, x, y, a, b;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> c[i][j];
if (c[i][j] == 'E') x = i, y = j;
if (c[i][j] == 'S') a = i, b = j;
}
}
queue<pair<int, int> > q;
memset(d, 0x3f, sizeof(d));
q.push({x, y});
d[x][y] = 0;
vis[x][y] = 0;
while (!q.empty()) {
int sx = q.front().first, sy = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int nx = dx[i] + sx, ny = dy[i] + sy;
if (nx > n || nx < 1 || ny > m || ny < 1 || c[nx][ny] == 'T' ||
vis[nx][ny])
continue;
d[nx][ny] = min(d[nx][ny], d[sx][sy] + 1);
vis[nx][ny] = 1;
q.push({nx, ny});
}
}
int num = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (c[i][j] >= '1' && c[i][j] <= '9') {
if (d[i][j] <= d[a][b]) num += (c[i][j] - '0');
}
}
}
cout << num << endl;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int i,j,k,n,m,t;
ll a[400500],res,sb;
int main(){
scanf("%d",&t);
while(t--){
res=0;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%lld",&a[i]);
}
a[n+1]=0;
for(i=1;i<=n;i++){
sb=max(a[i-1],a[i+1]);
if(sb<=a[i]){
res+=a[i]-sb;
a[i]=sb;
}
}
for(i=1;i<=n+1;i++){
res+=abs(a[i]-a[i-1]);
}
printf("%lld\n",res);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int query(int x, int y) {
if (x == -1) return 0;
cout << 1 << ' ' << x << ' ' << y << endl;
fflush(stdout);
string ret;
cin >> ret;
return ("TAK" == ret);
}
int get(int l, int r) {
if (l > r) return -1;
while (l < r) {
int m = (l + r) / 2;
if (query(m, m + 1)) {
r = m;
} else
l = m + 1;
}
return l;
}
int main() {
int n, k;
cin >> n >> k;
int x = get(1, n);
int y = get(1, x - 1);
if (!query(y, x)) y = get(x + 1, n);
cout << 2 << ' ' << x << ' ' << y << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int inf = 1 << 30;
const long long llinf = 1ll << 60;
using namespace std;
const int MAXN = 100000 + 5;
const int MAXE = MAXN * 2;
int n, m;
int to[MAXE], nxt[MAXE], head[MAXN], ne = 0;
int col[MAXN];
void inline ae(int f, int t) {
to[++ne] = t;
nxt[ne] = head[f];
head[f] = ne;
}
bool bicolor(int x, int c) {
if (col[x]) return col[x] == c;
col[x] = c;
for (int i = head[x]; i; i = nxt[i]) {
int v = to[i];
if (!bicolor(v, 3 - c)) return false;
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
ae(u, v);
ae(v, u);
}
for (int i = 1; i <= n; i++)
if (!col[i])
if (!bicolor(i, 1)) {
puts("-1");
return 0;
}
int num[3];
memset(num, 0, sizeof(num));
for (int i = 1; i <= n; i++) {
num[col[i]]++;
}
printf("%d\n", num[1]);
for (int i = 1; i <= n; i++)
if (col[i] == 1) printf("%d ", i);
puts("");
printf("%d\n", num[2]);
for (int i = 1; i <= n; i++)
if (col[i] == 2) printf("%d ", i);
puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
long long int power(long long int x, long long int y, long long int p) {
long long int temp;
if (y <= 0) return 1;
temp = power(x, y / 2, p);
if (y % 2 == 0) {
return (temp * temp) % p;
} else {
return (((x * temp) % p) * temp) % p;
}
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
long long int nCrModPFermat(long long int n, long long int r, long long int p) {
if (r == 0) {
return 1;
}
long long int fac[n + 1];
fac[0] = 1;
for (long long int i = 1; i <= n; i++) {
fac[i] = fac[i - 1] * i % p;
}
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
void leftRotatebyOne(long long int arr[], int n) {
int temp = arr[0], i;
for (i = 0; i < n - 1; i++) arr[i] = arr[i + 1];
arr[i] = temp;
}
void leftRotate(long long int arr[], int d, int n) {
for (int i = 0; i < d; i++) leftRotatebyOne(arr, n);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
long long int t;
cin >> t;
for (long long int j = 0; j < t; j++) {
long long int n, x, m;
cin >> n >> x >> m;
long long int left = x;
long long int right = x;
while (m--) {
long long int l, r;
cin >> l >> r;
if (!(l > right || r < left)) {
left = min(left, l);
right = max(right, r);
}
}
cout << right - left + 1 << endl;
}
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int a, b, c;
int gcd(int x, int y){
int t;
if( x < y ){
t = y;
y = x;
x = t;
}
while( y ){
t = x%y;
x = y;
y = t;
}
return x;
}
int abs(int x){
return x<0?-x:x;
}
int main(){
cin >> a >> b >> c;
while( a || b || c ){
bool possible = true;
int d = 0, x1, x2, u1, u2, s;
while( d*d < b*b - 4*a*c ) d++;
possible = (d*d == b*b - 4*a*c);
if( possible ){
s = (- b - d)/abs(- b - d);
x1 = abs(- b - d);
if( x1 ){
u1 = 2*a/gcd(x1, 2*a);
x1 = -s*x1/gcd(x1, 2*a);
u2 = a/u1;
x2 = c/x1;
}else{
u1 = 1;
u2 = a;
x2 = b;
}
if( u1 < u2 || (u1 == u2 && x1 < x2) ){
int t = x1;
x1 = x2;
x2 = t;
t = u1;
u1 = u2;
u2 = t;
}
cout << u1 << ' ' << x1 << ' ' << u2 << ' ' << x2 << endl;
}else{
cout << "Impossible" << endl;
}
cin >> a >> b >> c;
}
return 0;
}
| 0 |
#include<stdio.h>
#include<algorithm>
#include<functional>
using namespace std;
int main(void)
{
int n,i,e,h[65000];
unsigned int x,z,a,w;
while(1){
w=0;
scanf("%d",&n);
if(n==0) break;
for(i=0;i<n;i++){
scanf("%d",&e);
w+=e;
}
for(i=0;i<n-1;i++){
scanf("%d",&h[i]);
}
sort(h,h+n-1,greater<int>());
x=n*w;
z=w;
for(i=0;i<n-1;i++){
z=z+h[i];
a=(n-(i+1))*z;
if(a>x){
x=a;
}
}
printf("%u\n",x);
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.