input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
You have been given a set of N strings S1, S2, .... SN. Consider any non-empty string S (S need not belong to the given set of N strings). Suppose S occurs (as a substring) in K out of the N given strings in the set. Your job is to choose S such that the value of K is maximized. If there are many such strings, choose the one with the least length. If there are many such strings with the least length, choose the lexicographically smallest of them all.
Input:
The first line consists of T the number of test cases.
The first line in each test case consists of N, the number of words in the given set. Each of the next N lines contains a single word consisting of lowercase English alphabets (a-z) only.
Output:
Print the answer to each test case on a new line, the answer to each test case being a single string S as described in the problem above.
Constraints :
1 ≤ T ≤ 5
1 ≤ N ≤ 100
1 ≤ |Si| ≤ 100, |Si| denotes the length of the input words.
Author : Himanshu
Tester : Shreyans
(By IIT Kgp HackerEarth Programming Club)
SAMPLE INPUT
1
1
shades
SAMPLE OUTPUT
a
|
t=input()
for i in xrange(t):
n=input()
l=[]
for k in xrange(n):
s=raw_input()
l.append(s)
q="abcdefghijklmnopqrstuvwxyz"
o=[0 for i in xrange(26)]
for x in xrange(n):
for y in xrange(26):
if q[y] in l[x]:
o[y]+=1
z=max(o)
for j in xrange(26):
if o[j]==z:
print q[j]
break
|
There are N cells arranged in a row, numbered 1, 2, \ldots, N from left to right.
Tak lives in these cells and is currently on Cell 1. He is trying to reach Cell N by using the procedure described below.
You are given an integer K that is less than or equal to 10, and K non-intersecting segments [L_1, R_1], [L_2, R_2], \ldots, [L_K, R_K]. Let S be the union of these K segments. Here, the segment [l, r] denotes the set consisting of all integers i that satisfy l \leq i \leq r.
* When you are on Cell i, pick an integer d from S and move to Cell i + d. You cannot move out of the cells.
To help Tak, find the number of ways to go to Cell N, modulo 998244353.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq K \leq \min(N, 10)
* 1 \leq L_i \leq R_i \leq N
* [L_i, R_i] and [L_j, R_j] do not intersect (i \neq j)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
L_1 R_1
L_2 R_2
:
L_K R_K
Output
Print the number of ways for Tak to go from Cell 1 to Cell N, modulo 998244353.
Examples
Input
5 2
1 1
3 4
Output
4
Input
5 2
3 3
5 5
Output
0
Input
5 1
1 2
Output
5
Input
60 3
5 8
1 3
10 15
Output
221823067
|
import sys
input = sys.stdin.readline
N,K=map(int,input().split())
K=[tuple(map(int,input().split())) for i in range(K)]
mod=998244353
DP=[0]*(4*10**5+100)
DP[1]=1
DP[2]=-1
for i in range(1,N+1):
DP[i]+=DP[i-1]
DP[i]%=mod
for l,r in K:
DP[i+l]+=DP[i]
DP[i+l]%=mod
DP[i+r+1]-=DP[i]
DP[i+r+1]%=mod
#print(DP[:10])
print(DP[N])
|
There is a grass field that stretches infinitely.
In this field, there is a negligibly small cow. Let (x, y) denote the point that is x\ \mathrm{cm} south and y\ \mathrm{cm} east of the point where the cow stands now. The cow itself is standing at (0, 0).
There are also N north-south lines and M east-west lines drawn on the field. The i-th north-south line is the segment connecting the points (A_i, C_i) and (B_i, C_i), and the j-th east-west line is the segment connecting the points (D_j, E_j) and (D_j, F_j).
What is the area of the region the cow can reach when it can move around as long as it does not cross the segments (including the endpoints)? If this area is infinite, print `INF` instead.
Constraints
* All values in input are integers between -10^9 and 10^9 (inclusive).
* 1 \leq N, M \leq 1000
* A_i < B_i\ (1 \leq i \leq N)
* E_j < F_j\ (1 \leq j \leq M)
* The point (0, 0) does not lie on any of the given segments.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1 C_1
:
A_N B_N C_N
D_1 E_1 F_1
:
D_M E_M F_M
Output
If the area of the region the cow can reach is infinite, print `INF`; otherwise, print an integer representing the area in \mathrm{cm^2}.
(Under the constraints, it can be proved that the area of the region is always an integer if it is not infinite.)
Examples
Input
5 6
1 2 0
0 1 1
0 2 2
-3 4 -1
-2 6 3
1 0 1
0 1 2
2 0 2
-1 -4 5
3 -2 4
1 2 4
Output
13
Input
6 1
-3 -1 -2
-3 -1 1
-2 -1 2
1 4 -2
1 4 -1
1 4 1
3 1 4
Output
INF
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int N,M;
int A[1000],B[1000],C[1000];
int D[1000],E[1000],F[1000];
bool vis[3010][3010];
vector<pair<int,int> >WX[3010],WY[3010];
bool wx[3010][3010],wy[3010][3010];
int main()
{
cin>>N>>M;
vector<long>X,Y;
X.push_back((long)-2e9);
X.push_back(0);
X.push_back((long)2e9);
Y.push_back((long)-2e9);
Y.push_back(0);
Y.push_back((long)2e9);
for(int i=0;i<N;i++)
{
cin>>A[i]>>B[i]>>C[i];
X.push_back(A[i]);
X.push_back(B[i]);
Y.push_back(C[i]);
}
for(int i=0;i<M;i++)
{
cin>>D[i]>>E[i]>>F[i];
X.push_back(D[i]);
Y.push_back(E[i]);
Y.push_back(F[i]);
}
sort(X.begin(),X.end());
X.erase(unique(X.begin(),X.end()),X.end());
sort(Y.begin(),Y.end());
Y.erase(unique(Y.begin(),Y.end()),Y.end());
for(int i=0;i<N;i++)
{
A[i]=lower_bound(X.begin(),X.end(),A[i])-X.begin();
B[i]=lower_bound(X.begin(),X.end(),B[i])-X.begin();
C[i]=lower_bound(Y.begin(),Y.end(),C[i])-Y.begin();
WX[C[i]].push_back(make_pair(A[i],B[i]));
}
for(int i=0;i<M;i++)
{
D[i]=lower_bound(X.begin(),X.end(),D[i])-X.begin();
E[i]=lower_bound(Y.begin(),Y.end(),E[i])-Y.begin();
F[i]=lower_bound(Y.begin(),Y.end(),F[i])-Y.begin();
WY[D[i]].push_back(make_pair(E[i],F[i]));
}
WX[0].push_back(make_pair(0,X.size()+1));
WX[Y.size()].push_back(make_pair(0,X.size()+1));
for(int i=0;i<=Y.size();i++)
{
sort(WX[i].begin(),WX[i].end());
for(int j=0;j<WX[i].size();)
{
int L=WX[i][j].first,R=WX[i][j].second;
while(j<WX[i].size()&&WX[i][j].first<=R)
{
R=max(R,WX[i][j].second);
j++;
}
for(int k=L;k<R;k++)wx[i][k]=true;
}
}
WY[0].push_back(make_pair(0,Y.size()+1));
WY[X.size()].push_back(make_pair(0,Y.size()+1));
for(int i=0;i<=X.size();i++)
{
sort(WY[i].begin(),WY[i].end());
for(int j=0;j<WY[i].size();)
{
int L=WY[i][j].first,R=WY[i][j].second;
while(j<WY[i].size()&&WY[i][j].first<=R)
{
R=max(R,WY[i][j].second);
j++;
}
for(int k=L;k<R;k++)wy[i][k]=true;
}
}
queue<pair<int,int> >P;
vector<int>sx,sy;
{
int id=lower_bound(X.begin(),X.end(),0)-X.begin();
sx.push_back(id-1);
sx.push_back(id);
}
{
int id=lower_bound(Y.begin(),Y.end(),0)-Y.begin();
sy.push_back(id-1);
sy.push_back(id);
}
for(int x:sx)for(int y:sy)
{
vis[x][y]=true;
P.push(make_pair(x,y));
}
while(!P.empty())
{
int x=P.front().first,y=P.front().second;
P.pop();
if(!wy[x][y]&&!vis[x-1][y])
{
vis[x-1][y]=true;
P.push(make_pair(x-1,y));
}
if(!wx[y][x]&&!vis[x][y-1])
{
vis[x][y-1]=true;
P.push(make_pair(x,y-1));
}
if(!wy[x+1][y]&&!vis[x+1][y])
{
vis[x+1][y]=true;
P.push(make_pair(x+1,y));
}
if(!wx[y+1][x]&&!vis[x][y+1])
{
vis[x][y+1]=true;
P.push(make_pair(x,y+1));
}
}
long long ans=0;
for(int i=0;i<X.size();i++)for(int j=0;j<Y.size();j++)
{
if(!vis[i][j])continue;
if(i==0||j==0||i+1==X.size()||j+1==Y.size())
{
cout<<"INF"<<endl;
return 0;
}
ans+=(X[i+1]-X[i])*(Y[j+1]-Y[j]);
}
cout<<ans<<endl;
}
|
There are N children, numbered 1,2,\ldots,N. In the next K days, we will give them some cookies. In the i-th day, we will choose a_i children among the N with equal probability, and give one cookie to each child chosen. (We make these K choices independently.)
Let us define the happiness of the children as c_1 \times c_2 \times \ldots \times c_N, where c_i is the number of cookies received by Child i in the K days. Find the expected happiness multiplied by \binom{N}{a_1} \times \binom{N}{a_2} \times \ldots \times \binom{N}{a_K} (we can show that this value is an integer), modulo (10^{9}+7).
Constraints
* 1 \leq N \leq 1000
* 1 \leq K \leq 20
* 1 \leq a_i \leq N
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \ldots a_K
Output
Print the answer.
Examples
Input
3 2
3 2
Output
12
Input
856 16
399 263 665 432 206 61 784 548 422 313 848 478 827 26 398 63
Output
337587117
|
n,k = map(int,input().split())
a = tuple(map(int,input().split()))
mod = 10**9+7
rng = 1001
fctr = [1]
finv = [1]
for i in range(1,rng):
fctr.append(fctr[-1]*i%mod)
finv.append(pow(fctr[i],mod-2,mod))
dp = [[0 for i in range(n+1)] for j in range(k+1)]
dp[0][0] = 1
for i in range(1,k+1):
x = a[i-1]
for j in range(n+1):
if dp[i-1][j] == 0:
continue
y = dp[i-1][j]*fctr[n-j]*finv[n-x]%mod
for t in range(min(n-j,x)+1):
dp[i][j+t]=(dp[i][j+t]+y*fctr[n-t]*finv[n-j-t]*finv[t]*finv[x-t])%mod
print(dp[k][n])
|
For a sequence S of positive integers and positive integers k and l, S is said to belong to level (k,l) when one of the following conditions is satisfied:
* The length of S is 1, and its only element is k.
* There exist sequences T_1,T_2,...,T_m (m \geq l) belonging to level (k-1,l) such that the concatenation of T_1,T_2,...,T_m in this order coincides with S.
Note that the second condition has no effect when k=1, that is, a sequence belongs to level (1,l) only if the first condition is satisfied.
Given are a sequence of positive integers A_1,A_2,...,A_N and a positive integer L. Find the number of subsequences A_i,A_{i+1},...,A_j (1 \leq i \leq j \leq N) that satisfy the following condition:
* There exists a positive integer K such that the sequence A_i,A_{i+1},...,A_j belongs to level (K,L).
Constraints
* 1 \leq N \leq 2 \times 10^5
* 2 \leq L \leq N
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N L
A_1 A_2 ... A_N
Output
Print the number of subsequences A_i,A_{i+1},...,A_j (1 \leq i \leq j \leq N) that satisfy the condition.
Examples
Input
9 3
2 1 1 1 1 1 1 2 3
Output
22
Input
9 2
2 1 1 1 1 1 1 2 3
Output
41
Input
15 3
4 3 2 1 1 1 2 3 2 2 1 1 1 2 2
Output
31
|
#include<cstdio>
#include<queue>
#include<vector>
#include<iostream>
using namespace std;
#define mp make_pair
#define fi first
#define se second
const int MAXN = 200000;
typedef pair<int, int> pii;
typedef long long ll;
priority_queue<pii, vector<pii>, greater<pii> >que;
int lst[MAXN + 5], nxt[MAXN + 5], N, L;
void link(int x, int y) {lst[y] = x, nxt[x] = y;}
bool check(int x, int y) {return nxt[x] == y;}
ll lf[MAXN + 5], rf[MAXN + 5], f1[MAXN + 5], f2[MAXN + 5];
vector<int>v1, v2;
ll solve(int x) {
ll ret = 0, tmp = 0;
int lt = v2.size(), lb = lst[v2[0]], rb = nxt[v2[lt-1]];
for(int i=0;i<lt;i++) {
if( i - L + 1 >= 0 ) tmp += lf[v2[i-L+1]];
ret += tmp * rf[v2[i]];
}
for(int i=0;i<lt;i++)
f1[v2[i]] = lf[v2[i]], f2[v2[i]] = rf[v2[i]], lf[v2[i]] = rf[v2[i]] = 0;
int c = lt / L;
if( c ) {
for(int i=L-1;i<lt;i++) {
int t = (i + 1)/L - 1;
rf[v2[t]] += f2[v2[i]];
}
for(int i=lt-L;i>=0;i--) {
int t = c - (lt - i)/L;
lf[v2[t]] += f1[v2[i]];
}
for(int i=1;i<c;i++)
link(v2[i-1], v2[i]);
link(lb, v2[0]), link(v2[c-1], rb);
for(int i=0;i<c;i++)
que.push(mp(x + 1, v2[i]));
tmp = 0;
for(int i=0;i<c;i++) {
if( i - L + 1 >= 0 ) tmp += lf[v2[i-L+1]];
ret -= tmp * rf[v2[i]];
}
}
else nxt[lb] = N + 1, lst[rb] = 0;
v2.clear();
return ret;
}
int main() {
scanf("%d%d", &N, &L);
for(int i=1;i<=N;i++) {
int x; scanf("%d", &x);
que.push(mp(x, i)), link(i, i + 1);
lf[i] = rf[i] = 1;
}
ll ans = 0; link(0, 1);
while( !que.empty() ) {
int x = que.top().fi; v1.clear();
while( !que.empty() && que.top().fi == x )
v1.push_back(que.top().se), que.pop();
v2.clear(); v2.push_back(v1[0]);
for(int i=1;i<v1.size();i++) {
if( !check(v1[i-1], v1[i]) )
ans += solve(x);
v2.push_back(v1[i]);
}
ans += solve(x);
}
printf("%lld\n", ans + N);
}
|
There are N squares numbered 1 to N from left to right. Each square has a character written on it, and Square i has a letter s_i. Besides, there is initially one golem on each square.
Snuke cast Q spells to move the golems.
The i-th spell consisted of two characters t_i and d_i, where d_i is `L` or `R`. When Snuke cast this spell, for each square with the character t_i, all golems on that square moved to the square adjacent to the left if d_i is `L`, and moved to the square adjacent to the right if d_i is `R`.
However, when a golem tried to move left from Square 1 or move right from Square N, it disappeared.
Find the number of golems remaining after Snuke cast the Q spells.
Constraints
* 1 \leq N,Q \leq 2 \times 10^{5}
* |s| = N
* s_i and t_i are uppercase English letters.
* d_i is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N Q
s
t_1 d_1
\vdots
t_{Q} d_Q
Output
Print the answer.
Examples
Input
3 4
ABC
A L
B L
B R
A R
Output
2
Input
8 3
AABCBDBA
A L
B R
A R
Output
5
Input
10 15
SNCZWRCEWB
B R
R R
E R
W R
Z L
S R
Q L
W L
B R
C L
A L
N L
E R
Z L
S L
Output
3
|
import java.util.*;
public class Main {
static int n;
static String s;
static int q;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
q = sc.nextInt();
s = sc.next();
char[] t = new char[q];
char[] d = new char[q];
for (int i = 0; i < q; i++) {
t[i] = sc.next().charAt(0);
d[i] = sc.next().charAt(0);
}
int left = binSearch(t, d, -1, n);
// System.out.println("left = " + left);
int right = binSearch(t, d, n, -1);
// System.out.println("right = " + right);
int ans = Math.max(0, right - left - 1);
System.out.println(ans);
}
public static int binSearch(char[] t, char[] d, int ok, int ng) {
int out = ok;
while (Math.abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (solve(mid, t, d, out)) {
ok = mid;
} else {
ng = mid;
}
// System.out.printf("ok = %d,ng = %d %n", ok, ng);
}
return ok;
}
public static boolean solve(int mid, char[] t, char[] d, int out) {
for (int i = 0; i < q; i++) {
if (mid == -1 || mid == n) {
return false;
}
char ch = s.charAt(mid);
// System.out.println("ch = " + ch);
// System.out.println("mid = " + mid);
// System.out.printf("t[%d] = %s %n", i, t[i]);
// System.out.printf("d[%d] = %s %n", i, d[i]);
if (ch != t[i]) {
continue;
}
if (d[i] == 'L') {
mid--;
} else if (d[i] == 'R') {
mid++;
}
if (mid == out) {
// System.out.println("out mid = " + mid);
return true;
}
}
return false;
}
}
|
You are given a sequence of N integers: A_1,A_2,...,A_N.
Find the number of permutations p_1,p_2,...,p_N of 1,2,...,N that can be changed to A_1,A_2,...,A_N by performing the following operation some number of times (possibly zero), modulo 998244353:
* For each 1\leq i\leq N, let q_i=min(p_{i-1},p_{i}), where p_0=p_N. Replace the sequence p with the sequence q.
Constraints
* 1 \leq N \leq 3 × 10^5
* 1 \leq A_i \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print the number of the sequences that satisfy the condition, modulo 998244353.
Examples
Input
3
1
2
1
Output
2
Input
5
3
1
4
1
5
Output
0
Input
8
4
4
4
1
1
1
2
2
Output
24
Input
6
1
1
6
2
2
2
Output
0
|
#include <bits/stdc++.h>
// iostream is too mainstream
#include <cstdio>
// bitch please
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <cmath>
#include <iomanip>
#include <time.h>
#define dibs reserve
#define OVER9000 1234567890
#define ALL_THE(CAKE,LIE) for(auto LIE =CAKE.begin(); LIE != CAKE.end(); LIE++)
#define tisic 47
#define soclose 1e-8
#define chocolate win
// so much chocolate
#define patkan 9
#define ff first
#define ss second
#define abs(x) (((x) < 0)?-(x):(x))
#define uint unsigned int
#define dbl long double
#define pi 3.14159265358979323846
using namespace std;
// mylittledoge
using cat = long long;
#ifdef DONLINE_JUDGE
// palindromic tree is better than splay tree!
#define lld I64d
#endif
int get_min(vector< vector<int> > & RMQ, int l, int r) {
int ret = OVER9000;
for(int i = 0; i < 19; i++) if(((r-l)>>i)&1) {
ret = min(ret, RMQ[i][l]);
l += 1<<i;
if(l == r) break;
}
return ret;
}
int get_max(vector< vector<int> > & RMQ, int l, int r) {
int ret = -1;
for(int i = 0; i < 19; i++) if(((r-l)>>i)&1) {
ret = max(ret, RMQ[i][l]);
l += 1<<i;
if(l == r) break;
}
return ret;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int N;
cin >> N;
vector<int> A(N), cnt(N, 0);
for(int i = 0; i < N; i++) {
cin >> A[i];
cnt[--A[i]]++;
}
int K = cnt[0];
if(K == 0) {
cout << "0\n";
return 0;
}
if(cnt[0] == N) {
cat ans = 1, mod = 998244353;
for(int i = 0; i < N; i++) ans = ans * (i+1) % mod;
cout << ans << "\n";
return 0;
}
vector< vector<int> > occ(N);
for(int i = 0; i < N; i++) occ[A[i]].push_back(i);
vector<int> first_idx(N);
first_idx[0] = occ[0][0];
while(A[(first_idx[0]+N-1)%N] == 0) first_idx[0] = (first_idx[0]+N-1)%N;
for(int i = 1; i < N; i++) if(cnt[i]) {
if(cnt[i] == 1) {
first_idx[i] = occ[i][0];
continue;
}
int x = 0;
for(int j = 0; j < (int)occ[i].size(); j++) {
int d = occ[i][(j+1)%occ[i].size()]-occ[i][j];
while(d < 0) d += N;
while(d >= N) d -= N;
if(d >= N-N/2) first_idx[i] = occ[i][(j+1)%occ[i].size()], x++;
}
if(x != 1) {
cout << "0\n";
return 0;
}
}
for(int i = 0; i < N; i++) if(cnt[i])
for(int j = 0; j < (int)occ[i].size(); j++) if(occ[i][j] == first_idx[i]) {
vector<int> occ_nw;
for(int k = 0; k < (int)occ[i].size(); k++) occ_nw.push_back(occ[i][(j+k)%occ[i].size()]);
occ[i] = occ_nw;
break;
}
for(int i = 0; i < K; i++) if(occ[0][i] != (first_idx[0]+i)%N) {
cout << "0\n";
return 0;
}
vector< pair<int, int> > R(N);
for(int i = 0; i < N; i++) if(cnt[i]) {
int x = occ[i].back()-K+1;
while(x < 0) x += N;
x %= N;
R[i] = {x, occ[i][0]};
int d = occ[i].back()-occ[i][0];
while(d < 0) d += N;
d %= N;
if(d >= K) {
cout << "0\n";
return 0;
}
}
vector< vector<int> > RMQ_max(19, vector<int>(N));
RMQ_max[0] = A;
for(int i = 1; i < 19; i++) for(int j = 0; j < N; j++)
RMQ_max[i][j] = max(RMQ_max[i-1][j], RMQ_max[i-1][min(N-1, j + (1<<(i-1)))]);
vector<int> minval(N);
for(int i = 0; i < N; i++) {
minval[i] = get_max(RMQ_max, i, min(N, i+K));
if(i+K > N) minval[i] = max(minval[i], get_max(RMQ_max, 0, i+K-N));
}
vector< vector<int> > RMQ_min(19, vector<int>(N));
RMQ_min[0] = minval;
for(int i = 1; i < 19; i++) for(int j = 0; j < N; j++)
RMQ_min[i][j] = min(RMQ_min[i-1][j], RMQ_min[i-1][min(N-1, j + (1<<(i-1)))]);
for(int i = 0; i < N; i++) if(cnt[i]) {
int r = (R[i].ss >= R[i].ff) ? R[i].ss : (N-1);
for(int j = 18; j >= 0; j--) while(R[i].ff+(1<<j) <= r) {
if(RMQ_min[j][R[i].ff] <= i) break;
R[i].ff += 1<<j;
}
for(int j = 0; j < 3; j++) {
if(minval[R[i].ff] <= i) break;
if(R[i].ff == R[i].ss) {
cout << "0\n";
return 0;
}
R[i].ff = (R[i].ff+1)%N;
}
r = (R[i].ss >= R[i].ff) ? R[i].ss : (N-1);
for(int j = 18; j >= 0; j--) while(R[i].ff+(1<<j) <= r) {
if(RMQ_min[j][R[i].ff] <= i) break;
R[i].ff += 1<<j;
}
int l = (R[i].ff <= R[i].ss) ? R[i].ff : 0;
for(int j = 18; j >= 0; j--) while(R[i].ss-(1<<j) >= l) {
if(RMQ_min[j][R[i].ss-(1<<j)+1] <= i) break;
R[i].ss -= 1<<j;
}
for(int j = 0; j < 3; j++) {
if(minval[R[i].ss] <= i) break;
if(R[i].ff == R[i].ss) {
cout << "0\n";
return 0;
}
R[i].ss = (R[i].ss+N-1)%N;
}
l = (R[i].ff <= R[i].ss) ? R[i].ff : 0;
for(int j = 18; j >= 0; j--) while(R[i].ss-(1<<j) >= l) {
if(RMQ_min[j][R[i].ss-(1<<j)+1] <= i) break;
R[i].ss -= 1<<j;
}
}
vector<int> cnt_pos0(N, 0);
for(int i = 0; i < N; i++) cnt_pos0[minval[i]]++;
for(int i = 1; i < N; i++) cnt_pos0[i] += cnt_pos0[i-1];
cat ans = 1, mod = 998244353;
for(int i = 0; i < N; i++) {
if(cnt[i] == 0) {
if(cnt_pos0[i] <= i) {
cout << "0\n";
return 0;
}
ans = ans * (cnt_pos0[i]-i) % mod;
continue;
}
int d = R[i].ss-R[i].ff;
while(d < 0) d += N;
d %= N;
ans = ans * (d+1) % mod;
}
cout << ans << "\n";
return 0;
}
// look at my code
// my code is amazing
|
"Teishi-zushi", a Japanese restaurant, is a plain restaurant with only one round counter. The outer circumference of the counter is C meters. Customers cannot go inside the counter.
Nakahashi entered Teishi-zushi, and he was guided to the counter. Now, there are N pieces of sushi (vinegared rice with seafood and so on) on the counter. The distance measured clockwise from the point where Nakahashi is standing to the point where the i-th sushi is placed, is x_i meters. Also, the i-th sushi has a nutritive value of v_i kilocalories.
Nakahashi can freely walk around the circumference of the counter. When he reach a point where a sushi is placed, he can eat that sushi and take in its nutrition (naturally, the sushi disappears). However, while walking, he consumes 1 kilocalories per meter.
Whenever he is satisfied, he can leave the restaurant from any place (he does not have to return to the initial place). On balance, at most how much nutrition can he take in before he leaves? That is, what is the maximum possible value of the total nutrition taken in minus the total energy consumed? Assume that there are no other customers, and no new sushi will be added to the counter. Also, since Nakahashi has plenty of nutrition in his body, assume that no matter how much he walks and consumes energy, he never dies from hunger.
Constraints
* 1 ≤ N ≤ 10^5
* 2 ≤ C ≤ 10^{14}
* 1 ≤ x_1 < x_2 < ... < x_N < C
* 1 ≤ v_i ≤ 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N C
x_1 v_1
x_2 v_2
:
x_N v_N
Output
If Nakahashi can take in at most c kilocalories on balance before he leaves the restaurant, print c.
Examples
Input
3 20
2 80
9 120
16 1
Output
191
Input
3 20
2 80
9 1
16 120
Output
192
Input
1 100000000000000
50000000000000 1
Output
0
Input
15 10000000000
400000000 1000000000
800000000 1000000000
1900000000 1000000000
2400000000 1000000000
2900000000 1000000000
3300000000 1000000000
3700000000 1000000000
3800000000 1000000000
4000000000 1000000000
4100000000 1000000000
5200000000 1000000000
6600000000 1000000000
8000000000 1000000000
9300000000 1000000000
9700000000 1000000000
Output
6500000000
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Collections;
import java.util.InputMismatchException;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
public class Main {
static PrintWriter out;
static InputReader ir;
static void solve() {
int n = ir.nextInt();
long c = ir.nextLong();
long[][] a = new long[n][];
for (int i = 0; i < n; i++)
a[i] = ir.nextLongArray(2);
long[] t = new long[n + 1];
long ma = 0;
for (int i = 0; i < n; i++) {
t[i + 1] = t[i] + a[i][1];
ma = Math.max(ma, t[i + 1] - a[i][0]);
}
for (int i = 0; i < n; i++)
ma = Math.max(ma, t[n] - t[i] - (c - a[i][0]));
PriorityQueue<Long> pque = new PriorityQueue<>(Collections.reverseOrder());
pque.offer(0L);
for (int i = n - 1; i >= 0; i--) {
ma = Math.max(ma, t[i + 1] - a[i][0] * 2 + pque.peek());
pque.offer(t[n] - t[i] - (c - a[i][0]));
}
pque.clear();
pque.offer(0L);
for (int i = 0; i < n ; i++) {
ma = Math.max(ma, t[n] - t[i] - (c - a[i][0]) * 2 + pque.peek());
pque.offer(t[i + 1] - a[i][0]);
}
out.println(ma);
}
public static void main(String[] args) throws Exception {
ir = new InputReader(System.in);
out = new PrintWriter(System.out);
solve();
out.flush();
}
static class InputReader {
private InputStream in;
private byte[] buffer = new byte[1024];
private int curbuf;
private int lenbuf;
public InputReader(InputStream in) {
this.in = in;
this.curbuf = this.lenbuf = 0;
}
public boolean hasNextByte() {
if (curbuf >= lenbuf) {
curbuf = 0;
try {
lenbuf = in.read(buffer);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0)
return false;
}
return true;
}
private int readByte() {
if (hasNextByte())
return buffer[curbuf++];
else
return -1;
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private void skip() {
while (hasNextByte() && isSpaceChar(buffer[curbuf]))
curbuf++;
}
public boolean hasNext() {
skip();
return hasNextByte();
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = readByte();
while (!isSpaceChar(b)) {
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
public int nextInt() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public long nextLong() {
if (!hasNext())
throw new NoSuchElementException();
int c = readByte();
while (isSpaceChar(c))
c = readByte();
boolean minus = false;
if (c == '-') {
minus = true;
c = readByte();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res = res * 10 + c - '0';
c = readByte();
} while (!isSpaceChar(c));
return (minus) ? -res : res;
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++)
a[i] = nextInt();
return a;
}
public long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++)
a[i] = nextLong();
return a;
}
public char[][] nextCharMap(int n, int m) {
char[][] map = new char[n][m];
for (int i = 0; i < n; i++)
map[i] = next().toCharArray();
return map;
}
}
}
|
In CODE FESTIVAL XXXX, there are N+1 participants from all over the world, including Takahashi.
Takahashi checked and found that the time gap (defined below) between the local times in his city and the i-th person's city was D_i hours. The time gap between two cities is defined as follows. For two cities A and B, if the local time in city B is d o'clock at the moment when the local time in city A is 0 o'clock, then the time gap between these two cities is defined to be min(d,24-d) hours. Here, we are using 24-hour notation. That is, the local time in the i-th person's city is either d o'clock or 24-d o'clock at the moment when the local time in Takahashi's city is 0 o'clock, for example.
Then, for each pair of two people chosen from the N+1 people, he wrote out the time gap between their cities. Let the smallest time gap among them be s hours.
Find the maximum possible value of s.
Constraints
* 1 \leq N \leq 50
* 0 \leq D_i \leq 12
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D_1 D_2 ... D_N
Output
Print the maximum possible value of s.
Examples
Input
3
7 12 8
Output
4
Input
2
11 11
Output
2
Input
1
0
Output
0
|
#include <bits/stdc++.h>
#ifdef _WIN32
#include "debug.hpp"
#endif
using namespace std;
#define rep(i, N) for(int i = 0; i < (N); i++)
#define reps(i, N) for(int i = 1; i <= (N); i++)
#define repr(i, N) for(int i = (N) - 1; i >= 0; i--)
#define pub push_back
template<typename T>
void chmax(T &a, T b){ a = max(a, b); };
template<typename T>
void chmin(T &a, T b){ a = min(a, b); };
typedef long long ll;
typedef pair<int, int> P;
const int INF = 100000000;
const ll LINF = 10000000000000000;
const int MOD = 1000000007;
const int dx[9] = { 0, 1, 0, -1, 1, 1, -1, -1, 0};
const int dy[9] = { 1, 0, -1, 0, 1, -1, -1, 1, 0};
//--------------------------------------//
int N;
int D[51];
int b[24];
void solve(){
sort(D, D + N);
rep(i, N){
if(i % 2)
b[D[i]]++;
else
b[(24 - D[i]) % 24]++;
}
//da(b, 24);
int ans = INF;
int c = INF;
rep(i, 24){
if(b[i] > 1){
cout << 0 << endl;
return;
}
else if(b[i]){
chmin(ans, c);
c = 1;
}
else
c++;
}
cout << ans << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, N) {
cin >> D[i];
}
N++;
solve();
return 0;
}
|
In AtCoder, a person who has participated in a contest receives a color, which corresponds to the person's rating as follows:
* Rating 1-399 : gray
* Rating 400-799 : brown
* Rating 800-1199 : green
* Rating 1200-1599 : cyan
* Rating 1600-1999 : blue
* Rating 2000-2399 : yellow
* Rating 2400-2799 : orange
* Rating 2800-3199 : red
Other than the above, a person whose rating is 3200 or higher can freely pick his/her color, which can be one of the eight colors above or not.
Currently, there are N users who have participated in a contest in AtCoder, and the i-th user has a rating of a_i.
Find the minimum and maximum possible numbers of different colors of the users.
Constraints
* 1 ≤ N ≤ 100
* 1 ≤ a_i ≤ 4800
* a_i is an integer.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the minimum possible number of different colors of the users, and the maximum possible number of different colors, with a space in between.
Examples
Input
4
2100 2500 2700 2700
Output
2 2
Input
5
1100 1900 2800 3200 3200
Output
3 5
Input
20
800 810 820 830 840 850 860 870 880 890 900 910 920 930 940 950 960 970 980 990
Output
1 1
|
n,a=open(0)
s=set();x=0
for i in map(int,a.split()):
j=i//400
if j<8:s.add(j)
else:x+=1
print(max(1,len(s)),len(s)+x)
|
Joisino has a formula consisting of N terms: A_1 op_1 A_2 ... op_{N-1} A_N. Here, A_i is an integer, and op_i is an binary operator either `+` or `-`. Because Joisino loves large numbers, she wants to maximize the evaluated value of the formula by inserting an arbitrary number of pairs of parentheses (possibly zero) into the formula. Opening parentheses can only be inserted immediately before an integer, and closing parentheses can only be inserted immediately after an integer. It is allowed to insert any number of parentheses at a position. Your task is to write a program to find the maximum possible evaluated value of the formula after inserting an arbitrary number of pairs of parentheses.
Constraints
* 1≦N≦10^5
* 1≦A_i≦10^9
* op_i is either `+` or `-`.
Input
The input is given from Standard Input in the following format:
N
A_1 op_1 A_2 ... op_{N-1} A_N
Output
Print the maximum possible evaluated value of the formula after inserting an arbitrary number of pairs of parentheses.
Examples
Input
3
5 - 1 - 3
Output
7
Input
5
1 - 2 + 3 - 4 + 5
Output
5
Input
5
1 - 20 - 13 + 14 - 5
Output
13
|
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
int a[N];
long long f[N][3];
int main()
{
int n; scanf("%d%d",&n,&a[1]);
for(int i=2;i<=n;++i)
{
char op[2];
scanf("%s%d",op,&a[i]);
a[i]=(op[0]=='+'?a[i]:-a[i]);
}
f[1][0]=a[1],f[1][1]=f[1][2]=-1ll<<60;
for(int i=2;i<=n;++i)
{
f[i][0]=max(f[i-1][0],max(f[i-1][1],f[i-1][2]))+a[i];
f[i][1]=max(f[i-1][1],f[i-1][2])-a[i];
f[i][2]=f[i-1][2]+a[i];
if(a[i]<0)
{
f[i][1]=max(f[i][1],f[i-1][0]+a[i]);
f[i][1]=max(f[i][1],f[i-1][1]+a[i]);
f[i][1]=max(f[i][1],f[i-1][2]+a[i]);
f[i][2]=max(f[i][2],f[i-1][1]-a[i]);
f[i][2]=max(f[i][2],f[i-1][2]-a[i]);
}
}
printf("%lld",max(f[n][0],max(f[n][1],f[n][2])));
}
|
N hotels are located on a straight line. The coordinate of the i-th hotel (1 \leq i \leq N) is x_i.
Tak the traveler has the following two personal principles:
* He never travels a distance of more than L in a single day.
* He never sleeps in the open. That is, he must stay at a hotel at the end of a day.
You are given Q queries. The j-th (1 \leq j \leq Q) query is described by two distinct integers a_j and b_j. For each query, find the minimum number of days that Tak needs to travel from the a_j-th hotel to the b_j-th hotel following his principles. It is guaranteed that he can always travel from the a_j-th hotel to the b_j-th hotel, in any given input.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq L \leq 10^9
* 1 \leq Q \leq 10^5
* 1 \leq x_i < x_2 < ... < x_N \leq 10^9
* x_{i+1} - x_i \leq L
* 1 \leq a_j,b_j \leq N
* a_j \neq b_j
* N,\,L,\,Q,\,x_i,\,a_j,\,b_j are integers.
Input
The input is given from Standard Input in the following format:
N
x_1 x_2 ... x_N
L
Q
a_1 b_1
a_2 b_2
:
a_Q b_Q
Output
Print Q lines. The j-th line (1 \leq j \leq Q) should contain the minimum number of days that Tak needs to travel from the a_j-th hotel to the b_j-th hotel.
Example
Input
9
1 3 6 13 15 18 19 29 31
10
4
1 8
7 3
6 7
8 5
Output
4
2
1
2
|
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=100005;
int N,L,Q;
int x[MAXN],nxt[MAXN][25];
int ans[MAXN];
//int dis[MAXN];
int main()
{
scanf("%d",&N);
for(int i=1;i<=N;i++)
scanf("%d",&x[i]);
scanf("%d%d",&L,&Q);
memset(nxt,0x3F,sizeof nxt);
for(int i=1;i<=N;i++)
{
nxt[i][0]=lower_bound(x+1,x+N+1,x[i]+L)-x;
if(x[nxt[i][0]]>x[i]+L)
nxt[i][0]--;
}
for(int j=1;(1<<j)<N;j++)
for(int i=1;i<=N;i++)
if(nxt[i][j-1]!=0x3F3F3F3F&&nxt[nxt[i][j-1]][j-1]!=0x3F3F3F3F)
nxt[i][j]=nxt[nxt[i][j-1]][j-1];
for(int i=1,a,b;i<=Q;i++)
{
scanf("%d%d",&a,&b);
if(a>b)
swap(a,b);
int ans=0;
for(int j=20;j>=0;j--)
if(nxt[a][j]<=b)
{
a=nxt[a][j];
ans+=(1<<j);
}
if(a<b)
ans++;
printf("%d\n",ans);
}
return 0;
}
|
An English booklet has been created for publicizing Aizu to the world. When you read it carefully, you found a misnomer (an error in writing) on the last name of Masayuki Hoshina, the lord of the Aizu domain. The booklet says "Hoshino" not "Hoshina".
Your task is to write a program which replace all the words "Hoshino" with "Hoshina". You can assume that the number of characters in a text is less than or equal to 1000.
Input
The input consists of several datasets. There will be the number of datasets n in the first line. There will be n lines. A line consisting of english texts will be given for each dataset.
Output
For each dataset, print the converted texts in a line.
Example
Input
3
Hoshino
Hashino
Masayuki Hoshino was the grandson of Ieyasu Tokugawa.
Output
Hoshina
Hashino
Masayuki Hoshina was the grandson of Ieyasu Tokugawa.
|
#include <iostream>
#include <cstring>
using namespace std;
int main(){
int n,len;
string a;
cin>>n;
getline(cin,a);
for(int i=0;i<n;i++){
getline(cin,a);
len=a.size();
for(int o=0;o<=len;o++)
if(a[o]=='H'){
if(a[o+1]=='o')
if(a[o+2]=='s')
if(a[o+3]=='h')
if(a[o+4]=='i')
if(a[o+5]=='n')
if(a[o+6]=='o')
a[o+6]='a';}
cout<<a<<endl;}
return 0;
}
|
Aizu has an ancient legend of buried treasure. You have finally found the place where the buried treasure is buried. Since we know the depth of the buried treasure and the condition of the strata to be dug, we can reach the buried treasure at the lowest cost with careful planning. So you decided to create a program that reads the condition of the formation and calculates the route to reach the buried treasure depth at the lowest cost.
The state of the formation is represented by cells arranged in a two-dimensional grid, and the position of each cell is represented by the coordinates (x, y). Let the upper left be (1,1), and assume that the x coordinate increases as it goes to the right and the y coordinate increases as it goes deeper down. You choose one of the cells with the smallest y-coordinate and start digging from there, then dig into one of the cells with the largest y-coordinate. There are two types of cells in the formation:
1. A cell filled with soil. There is a fixed cost for each cell to dig.
2. Oxygen-filled cell. There is no need to dig, and each cell can be replenished with a fixed amount of oxygen. The oxygen in the cell that has been replenished with oxygen is exhausted and cannot be replenished again. Also, when you reach this cell, you must replenish oxygen.
Only left, right, and down cells can be dug from a cell. Once you have dug a cell, you can move it left or right, but you cannot move it up.
You must carry an oxygen cylinder with you when excavating. The moment the oxygen cylinder reaches zero, you will not be able to move, excavate, or replenish oxygen. The remaining amount is decremented by 1 each time you move the cell. Even if the remaining amount of the oxygen cylinder is 0 and the depth of the buried treasure is reached, it is not considered to have been reached. In addition, oxygen can be replenished in cells that have accumulated oxygen, but the excess capacity is discarded.
Create a program that inputs the size of the formation, the excavation cost, the capacity of the oxygen cylinder, the amount of oxygen in the initial state, and the information of the formation, and outputs the minimum cost to reach the deepest cell. However, if the minimum cost exceeds the excavation cost, or if you cannot reach the buried treasure no matter how you dig, please output "NA".
<image>
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two zero lines. Each dataset is given in the following format.
W H
f m o
c1,1 c2,1 ... cW,1
c1,2 c2,2 ... cW,2
...
c1, H c2, H ... cW, H
The horizontal size W of the formation and the vertical size H (3 ≤ W, H ≤ 10) are given in the first line. The second line is the integer f (1 ≤ f ≤ 10000) that represents your excavation cost, the integer m (3 ≤ m ≤ 50) that represents the capacity of the oxygen cylinder, and the integer o that represents the amount of oxygen you have in the initial state. o ≤ m) is given.
The following H line is given the geological information ci, j. ci, j represents the cell information for coordinates (i, j) and is given in the following format:
If the value is negative, the cell is full of soil and the value represents the cost.
If the value is positive, it is a cell filled with oxygen, and the value represents the amount of oxygen.
However, there are no more than 50 cells in which oxygen has accumulated.
The number of datasets does not exceed 50.
Output
Print the minimum cost or NA on one line for each dataset.
Example
Input
3 3
100 10 10
-100 -20 -100
-100 -20 -100
-100 -20 -100
3 3
100 10 10
-100 -20 -100
-100 -20 -20
-100 -60 -20
3 3
100 10 3
-100 -20 -100
-20 -20 -20
-20 -100 -20
3 3
100 3 3
-100 -20 -30
-100 -20 2
-100 -20 -20
4 5
1500 5 4
-10 -380 -250 -250
-90 2 -80 8
-250 -130 -330 -120
-120 -40 -50 -20
-250 -10 -20 -150
0 0
Output
60
80
NA
50
390
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <set>
using namespace std;
class Situation{
public:
int oxigen;
int money;
int h,w;
int miningCnt;
int bitmask;
set<pair<int,int> > visited;
};
int mem[11][11][1<<10][51];
int field[11][11];
const int INF=100000000;
const int dy[]={0,0,1};
const int dx[]={-1,1,0};
void solve(){
int h,w;
int f,m,o;
while(cin>>w>>h&&!(w==0&&h==0)){
queue<Situation> q;
for(int i = 0; i < 11; i++)
for(int j = 0; j < 11; j++)
for(int k = 0; k < (1<<10); k++)
fill(mem[i][j][k],mem[i][j][k]+51,INF);
cin>>f>>m>>o;
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
cin>>field[i][j];
field[i][j]=-field[i][j];
}
}
for(int i = 0; i < w; i++){
Situation s;
s.money=0;
s.miningCnt=1;
s.oxigen=o;
s.h=0;
s.w=i;
s.bitmask=(1<<i);
s.visited.insert(make_pair(s.h,s.w));
s.oxigen--;
if(s.oxigen>=1){
if(field[s.h][s.w]>0)
s.money+=field[s.h][s.w];
else
s.oxigen=min(m,s.oxigen-field[s.h][s.w]);
if(s.money<=f&&s.oxigen>=1){
mem[s.h][s.w][(1<<i)][s.oxigen]=s.money;
q.push(s);
}
}
}
int minGoalCost=INF;
while(q.size()){
Situation s=q.front();q.pop();
if(s.h==h-1||s.oxigen<=1){
if(s.h==h-1&&s.oxigen>=1)
minGoalCost=min(minGoalCost,s.money);
continue;
}
for(int i = 0; i < 3; i++){
int toH=s.h+dy[i];
int toW=s.w+dx[i];
int toCost=s.money;
int toOx=s.oxigen-1;
int toMining=s.miningCnt;
if(toH>=0&&toW>=0&&toH<h&&toW<w){
if(s.visited.find(make_pair(toH,toW))==s.visited.end()){
if(field[toH][toW]>0)
toCost+=field[toH][toW];
else
toOx=min(m,toOx-field[toH][toW]);
toMining++;
}
Situation ns;
ns.h=toH;
ns.w=toW;
ns.money=toCost;
ns.visited=s.visited;
ns.oxigen=toOx;
ns.visited.insert(make_pair(toH,toW));
ns.miningCnt=toMining;
ns.bitmask=s.bitmask;
if(i==2)
ns.bitmask=(1<<ns.w);
else
ns.bitmask|=(1<<ns.w);
if(mem[toH][toW][ns.bitmask][toOx]>toCost&&toCost<=f&&toCost<=minGoalCost){
if(toH!=h-1)
q.push(ns);
else
minGoalCost=min(minGoalCost,ns.money);
mem[toH][toW][ns.bitmask][toOx]=min(mem[toH][toW][ns.bitmask][toOx],toCost);
}
}
}
}
if(minGoalCost==INF)
cout<<"NA"<<endl;
else
cout<<minGoalCost<<endl;
}
}
int main(){
solve();
return 0;
}
|
Playing with Stones
Koshiro and Ukiko are playing a game with black and white stones. The rules of the game are as follows:
1. Before starting the game, they define some small areas and place "one or more black stones and one or more white stones" in each of the areas.
2. Koshiro and Ukiko alternately select an area and perform one of the following operations.
(a) Remove a white stone from the area
(b) Remove one or more black stones from the area. Note, however, that the number of the black stones must be less than or equal to white ones in the area.
(c) Pick up a white stone from the stone pod and replace it with a black stone. There are plenty of white stones in the pod so that there will be no shortage during the game.
3. If either Koshiro or Ukiko cannot perform 2 anymore, he/she loses.
They played the game several times, with Koshiro’s first move and Ukiko’s second move, and felt the winner was determined at the onset of the game. So, they tried to calculate the winner assuming both players take optimum actions.
Given the initial allocation of black and white stones in each area, make a program to determine which will win assuming both players take optimum actions.
Input
The input is given in the following format.
$N$
$w_1$ $b_1$
$w_2$ $b_2$
:
$w_N$ $b_N$
The first line provides the number of areas $N$ ($1 \leq N \leq 10000$). Each of the subsequent $N$ lines provides the number of white stones $w_i$ and black stones $b_i$ ($1 \leq w_i, b_i \leq 100$) in the $i$-th area.
Output
Output 0 if Koshiro wins and 1 if Ukiko wins.
Examples
Input
4
24 99
15 68
12 90
95 79
Output
0
Input
3
2 46
94 8
46 57
Output
1
|
#include<iostream>
#include<algorithm>
#include<set>
using namespace std;
int grundy[201][101];
int dfs(int w, int b){
if(grundy[w][b] >= 0){
return grundy[w][b];
}
set<int> st;
if(w > 0){
st.insert(dfs(w - 1, b));
}
if(b > 0){
st.insert(dfs(w + 1, b - 1));
}
for(int i = 1 ; i <= b && i <= w ; ++i){
st.insert(dfs(w, b - i));
}
int res = 0;
while(st.count(res)){
++res;
}
return grundy[w][b] = res;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
fill(grundy[0], grundy[201], -1);
grundy[0][0] = 0;
int n;
cin >> n;
int v = 0;
for(int i = 0 ; i < n ; ++i){
int w, b;
cin >> w >> b;
v ^= dfs(w, b);
}
if(v == 0){
cout << 1 << endl;
}else{
cout << 0 << endl;
}
return 0;
}
|
In ancient times, Romans constructed numerous water ways to supply water to cities and industrial sites. These water ways were amongst the greatest engineering feats of the ancient world.
These water ways contributed to social infrastructures which improved people's quality of life. On the other hand, problems related to the water control and the water facilities are still interesting as a lot of games of water ways construction have been developed.
Your task is to write a program which reads a map and computes the minimum possible cost of constructing water ways from sources to all the cities.
<image>
As shown in Figure 1, the map is represented by H × W grid cells, where each cell represents source, city, flatland, or obstacle.
You can construct only one water way from a source, but there are no limitations on the length of that water way and it can provide water to any number of cities located on its path. You can not construct water ways on the obstacles.
Your objective is to bring water to all the city and minimize the number of cells which represent water ways. In the Figure 1, water ways are constructed in 14 cells which is the minimum cost.
The water ways must satisfy the following conditions:
* a water way cell is adjacent to at most 2 water way cells in four cardinal points.
* a source cell is adjacent to at most 1 water way cell in four cardinal points.
* there is no path from a source to other sources through water ways.
Constraints
* Judge data contains at most 60 data sets.
* 3 ≤ H, W ≤ 10
* 1 ≤ the number of sources, the number of cities ≤ 8
* The map is surrounded by obstacles.
* Sources are not adjacent each other(on the left, right, top and bottom)
* There is a solution.
Input
The input consists of multiple datasets. Each dataset consists of:
H W
H × W characters
The integers H and W are the numbers of rows and columns of the map. H × W characters denote the cells which contain:
* 'P': source
* '*': city
* '.': flatland
* '#': obstacle
The end of input is indicated by a line containing two zeros separated by a space.
Output
For each dataset, print the minimum cost to construct the water ways.
Examples
Input
3 8
########
#P....*#
########
10 10
##########
#P.......#
#..#*....#
#..#*.#.*#
#.....#*.#
#*.......#
#..##....#
#...#.P..#
#P......P#
##########
0 0
Output
5
14
Input
3 8
P....*#
10 10
P.......#
..#*....#
..#*.#.*#
.....#*.#
*.......#
..##....#
...#.P..#
P......P#
0 0
Output
5
14
|
#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 _3_ 1
using namespace std;
/*
15:25 -
?????????????????????????????????
??????????????????
??£??????
????????????????????¢????¨????
?????¨?????????????????????????°???????????????????????¶?????????????
---
_3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME?
_3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME?
_3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME?
_3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME?
_3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME?
_3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME?
_3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME?
_3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME? _3_ < DO YOU HAVE THE TIME?
_3_ IT'S A QUATER TO TEN >
_3_ !!
*/
typedef unsigned long long ull;
typedef pair<int,int> ii;
struct Point { int x,y; };
const int IINF = INT_MAX;
const char PATH = '$';
int h,w,s_size,c_size,bitIndex[12][12];
char c[12][12];
Point source[12],city[12],path[12];
int limit,next_limit;
int dx[] = {0,1,0,-1};
int dy[] = {1,0,-1,0};
int mini;
int bc[1<<9];
int mani[12];
int initial_heuristic(){
int sum = 0;
rep(i,c_size) {
mani[i] = IINF;
rep(j,s_size) mani[i] = min(mani[i],abs(city[i].x-source[j].x)+abs(city[i].y-source[j].y));
rep(j,c_size) if( j != i ) mani[i] = min(mani[i],abs(city[i].x-city[j].x)+abs(city[i].y-city[j].y));
sum += mani[i];
}
return sum;
}
int get_heuristic(int sp,int bitmask){
int sum = 0;
rep(i,c_size) if( !( (bitmask>>i) & 1 ) ) {
mani[i] = min(mani[i],abs(path[sp].x-city[i].x)+abs(path[sp].y-city[i].y));
sum += mani[i];
}
return sum;
}
//typedef pair<ull,int> ullInt;
//map<ullInt,int> mincost;
//unordered_map<ull,int> mincost;
//map<ull,int> mincost;
bool head[12][12];
bool opt[12][12];
int blocks;
void print_field(){
rep(i,h) {
rep(j,w){
cout << c[i][j];
} puts("");
}
}
void dfs(int sp,int bitmask,int prev,int step,int depth){
/*
cout << "sp = " << sp << " step = " << step << endl;
print_field(); puts("");
*/
if( step+(c_size-bc[bitmask]) >= mini ) return;
if( sp >= s_size ) return;
if( bitmask == ((1<<c_size)-1) ) {
//print_field(); puts("");
mini = step; return; }
//int h = get_heuristic(sp,bitmask);
//if( step+h >= mini ) return;
bool next = 1;
rep(dir,4){
if( prev != -1 && ( prev + 2 ) % 4 == dir ) continue;
int nx = path[sp].x + dx[dir], ny = path[sp].y + dy[dir];
if( c[ny][nx] == 'P' || c[ny][nx] == '#' || c[ny][nx] == PATH ) continue;
bool success = true;
int cnt = 0;
rep(i,4){
int nx2 = nx + dx[i], ny2 = ny + dy[i];
if( c[ny2][nx2] == PATH || c[ny2][nx2] == 'P' ) ++cnt;
}
if( cnt != 1 ) success = false;
if( !success ) continue;
Point pp = path[sp];
char pc = c[ny][nx];
int nbitmask = bitmask;
bool fin = false;
char prec = c[ny][nx];
if( c[ny][nx] == '*' ) nbitmask |= (1<<bitIndex[ny][nx]), fin = true;
path[sp] = (Point){nx,ny};
c[ny][nx] = PATH;
//short mini_temp[8];
//rep(i,c_size) mini_temp[i] = mani[i];
swap(head[path[sp].y][path[sp].x],head[ny][nx]);
next = 0;
dfs(sp,nbitmask,dir,step+1,depth+1);
if( prec == '*' )dfs(sp+1,nbitmask,-1,step+1,0);
//rep(i,c_size) mani[i] = mini_temp[i];
swap(head[path[sp].y][path[sp].x],head[ny][nx]);
path[sp] = pp;
c[ny][nx] = pc;
//if( c_size-(int)__builtin_popcount(bitmask) == 1 ) return false;
if( fin ) return;
}
//if( c[path[sp].y][path[sp].x] == '*' || current_step == 0 ) dfs(sp+1,bitmask,-1,step,0);
//dfs(sp+1,bitmask,-1,step);
if( depth == 0 || c[path[sp].y][path[sp].x] == 'P' || c[path[sp].y][path[sp].x] == '*' ) dfs(sp+1,bitmask,-1,step,0);
}
int compute(){
//initial_heuristic();
mini = h*w-s_size - blocks;
int csv = 0;
dfs(0,0,-1,0,0);
return mini;
}
int main(){
srand((unsigned int)time(NULL));
rep(i,(1<<9)) bc[i] = __builtin_popcount(i);
while( scanf(" %d %d",&h,&w), h|w ){
s_size = c_size = 0;
blocks = 0;
rep(i,h) rep(j,w) {
head[i][j] = false;
scanf(" %c",&c[i][j]);
if( c[i][j] == 'P' ) { source[s_size] = path[s_size] = (Point){j,i}; s_size++; head[i][j] = true; }
if( c[i][j] == '*' ) { city[c_size] = (Point){j,i}; bitIndex[i][j] = c_size++; }
if( c[i][j] == '#' ) ++blocks;
}
printf("%d\n",compute());
//print_field(); puts("");
}
return 0;
}
|
You are working for an administration office of the International Center for Picassonian Cubism (ICPC), which plans to build a new art gallery for young artists. The center is organizing an architectural design competition to find the best design for the new building.
Submitted designs will look like a screenshot of a well known game as shown below.
<image>
This is because the center specifies that the building should be constructed by stacking regular units called pieces, each of which consists of four cubic blocks. In addition, the center requires the competitors to submit designs that satisfy the following restrictions.
* All the pieces are aligned. When two pieces touch each other, the faces of the touching blocks must be placed exactly at the same position.
* All the pieces are stable. Since pieces are merely stacked, their centers of masses must be carefully positioned so as not to collapse.
* The pieces are stacked in a tree-like form in order to symbolize boundless potentiality of young artists. In other words, one and only one piece touches the ground, and each of other pieces touches one and only one piece on its bottom faces.
* The building has a flat shape. This is because the construction site is a narrow area located between a straight moat and an expressway where no more than one block can be placed between the moat and the expressway as illustrated below.
<image>
It will take many days to fully check stability of designs as it requires complicated structural calculation. Therefore, you are asked to quickly check obviously unstable designs by focusing on centers of masses. The rules of your quick check are as follows.
Assume the center of mass of a block is located at the center of the block, and all blocks have the same weight. We denote a location of a block by xy-coordinates of its left-bottom corner. The unit length is the edge length of a block.
Among the blocks of the piece that touch another piece or the ground on their bottom faces, let xL be the leftmost x-coordinate of the leftmost block, and let xR be the rightmost x-coordinate of the rightmost block. Let the x-coordinate of its accumulated center of mass of the piece be M, where the accumulated center of mass of a piece P is the center of the mass of the pieces that are directly and indirectly supported by P, in addition to P itself. Then the piece is stable, if and only if xL < M < xR. Otherwise, it is unstable. A design of a building is unstable if any of its pieces is unstable.
Note that the above rules could judge some designs to be unstable even if it would not collapse in reality. For example, the left one of the following designs shall be judged to be unstable.
<image> | | <image>
---|---|---
Also note that the rules judge boundary cases to be unstable. For example, the top piece in the above right design has its center of mass exactly above the right end of the bottom piece. This shall be judged to be unstable.
Write a program that judges stability of each design based on the above quick check rules.
Input
The input is a sequence of datasets. The end of the input is indicated by a line containing two zeros separated by a space. Each dataset, which represents a front view of a building, is formatted as follows.
> w h
> p0(h-1)p1(h-1)...p(w-1)(h-1)
> ...
> p01p11...p(w-1)1
> p00p10...p(w-1)0
>
The integers w and h separated by a space are the numbers of columns and rows of the layout, respectively. You may assume 1 ≤ w ≤ 10 and 1 ≤ h ≤ 60. The next h lines specify the placement of the pieces. The character pxy indicates the status of a block at (x,y), either ``.`', meaning empty, or one digit character between ``1`' and ``9`', inclusive, meaning a block of a piece. (As mentioned earlier, we denote a location of a block by xy-coordinates of its left-bottom corner.)
When two blocks with the same number touch each other by any of their top, bottom, left or right face, those blocks are of the same piece. (Note that there might be two different pieces that are denoted by the same number.) The bottom of a block at (x,0) touches the ground.
You may assume that the pieces in each dataset are stacked in a tree-like form.
Output
For each dataset, output a line containing a word `STABLE` when the design is stable with respect to the above quick check rules. Otherwise, output `UNSTABLE`. The output should be written with uppercase letters, and should not contain any other extra characters.
Sample Input
4 5
..33
..33
2222
..1.
.111
5 7
....1
.1..1
.1..1
11..1
.2222
..111
...1.
3 6
.3.
233
23.
22.
.11
.11
4 3
2222
..11
..11
4 5
.3..
33..
322.
2211
.11.
3 3
222
2.1
111
3 4
11.
11.
.2.
222
3 4
.11
.11
.2.
222
2 7
11
.1
21
22
23
.3
33
2 3
1.
11
.1
0 0
Output for the Sample Input
STABLE
STABLE
STABLE
UNSTABLE
STABLE
STABLE
UNSTABLE
UNSTABLE
UNSTABLE
UNSTABLE
Example
Input
4 5
..33
..33
2222
..1.
.111
5 7
....1
.1..1
.1..1
11..1
.2222
..111
...1.
3 6
.3.
233
23.
22.
.11
.11
4 3
2222
..11
..11
4 5
.3..
33..
322.
2211
.11.
3 3
222
2.1
111
3 4
11.
11.
.2.
222
3 4
.11
.11
.2.
222
2 7
11
.1
21
22
23
.3
33
2 3
1.
11
.1
0 0
Output
STABLE
STABLE
STABLE
UNSTABLE
STABLE
STABLE
UNSTABLE
UNSTABLE
UNSTABLE
UNSTABLE
|
#include <iostream>
#include <algorithm>
#include <cctype>
#include <vector>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define fs first
#define sc second
typedef pair<int,int> P;
int w,h,dw[4]={1,0,-1,0},dh[4]={0,1,0,-1};
double eps=1e-8;
bool visited[61][10];
vector<string> vc;
struct st{
bool ok;
double wei,g;
};
vector<P> dfs(int hh,int ww,int id){
// cout << " " << hh << ww << id << endl;
visited[hh][ww]=true;
vector<P> ret;
ret.push_back(P(hh,ww));
rep(i,4){
int nh=hh+dh[i],nw=ww+dw[i];
if(0<=nw && nw<w && 0<=nh && nh<h && !visited[nh][nw] && vc[nh][nw]==id+'0'){
vector<P> pl=dfs(nh,nw,id);
ret.insert(ret.end(),pl.begin(),pl.end());
}
}
return ret;
}
st stable(vector<P> b,double l,double r){
// cout << "stable" << b[0].fs << " " << b[0].sc << endl;
double al=0,w=4;
rep(i,4) al+=b[i].sc;
rep(i,4){
// cout << "instable " << b[0].fs << " " << b[0].sc << " i=" << i << endl;
if(isdigit(vc[b[i].fs+1][b[i].sc]) && vc[b[i].fs+1][b[i].sc]!=vc[b[i].fs][b[i].sc] && !visited[b[i].fs+1][b[i].sc]){
int id=vc[b[i].fs+1][b[i].sc]-'0';
// cout << "id " << id << endl;
vector<P> nb=dfs(b[i].fs+1,b[i].sc,id);
double l=100,r=-100;
/* rep(j,h+1){
rep(k,w) cout << vc[h-j][k];
cout << endl;
}
cout << nb.size() << endl;*/
rep(j,4){
// cout << "j " << j << " " << nb[j].fs << " " << nb[j].sc << endl;
char c=vc[nb[j].fs-1][nb[j].sc];
if(isdigit(c) && c!=id+'0') r=max(r,0.5+nb[j].sc),l=min(l,-0.5+nb[j].sc);
}
// cout << "end" << endl;
st s=stable(nb,l,r);
if(!s.ok) return {false,0,0};
al+=s.wei*s.g;
w+=s.wei;
}
}
if(l+eps<al/w && al/w+eps<r){
// cout << "l=" << l << " , r=" << r << " g=" << al/w << endl;
return {true,w,al/w};
}
else return {false,0,0};
}
int main(){
while(true){
cin >> w >> h;
if(!w) break;
vc.clear();
vc.push_back(string(w,'.'));
rep(i,h){
string s;
cin >> s;
vc.push_back(s);
}
reverse(vc.begin(),vc.end());
int l=100,r=-100;
rep(j,w) if(isdigit(vc[0][j])) l=min(l,j),r=max(r,j);
// cout << l << r << endl;
rep(i,h) rep(j,w) visited[i][j]=0;
vector<P> f=dfs(0,l,vc[0][l]-'0');
// cout << f.size() << endl;
rep(i,h) rep(j,w) visited[i][j]=0;
cout << (stable(f,-0.5+l,0.5+r).ok ? "" : "UN") << "STABLE\n";
}
}
|
You are working as a night watchman in an office building. Your task is to check whether all the lights in the building are turned off after all the office workers in the building have left the office. If there are lights that are turned on, you must turn off those lights. This task is not as easy as it sounds to be because of the strange behavior of the lighting system of the building as described below. Although an electrical engineer checked the lighting system carefully, he could not determine the cause of this behavior. So you have no option but to continue to rely on this system for the time being.
Each floor in the building consists of a grid of square rooms. Every room is equipped with one light and one toggle switch. A toggle switch has two positions but they do not mean fixed ON/OFF. When the position of the toggle switch of a room is changed to the other position, in addition to that room, the ON/OFF states of the lights of the rooms at a certain Manhattan distance from that room are reversed. The Manhattan distance between the room at (x1, y1) of a grid of rooms and the room at (x2, y2) is given by |x1 - x2| + |y1 - y2|. For example, if the position of the toggle switch of the room at (2, 2) of a 4 × 4 grid of rooms is changed and the given Manhattan distance is two, the ON/OFF states of the lights of the rooms at (1, 1), (1, 3), (2, 4), (3, 1), (3, 3), and (4, 2) as well as at (2, 2) are reversed as shown in Figure D.1, where black and white squares represent the ON/OFF states of the lights.
<image>
Figure D.1: An example behavior of the lighting system
Your mission is to write a program that answer whether all the lights on a floor can be turned off.
Input
The input is a sequence of datasets. Each dataset is formatted as follows.
m n d
S11 S12 S13 ... S1m
S21 S22 S23 ... S2m
...
Sn1 Sn2 Sn3 ... Snm
The first line of a dataset contains three integers. m and n (1 ≤ m ≤ 25, 1 ≤ n ≤ 25) are the numbers of columns and rows of the grid, respectively. d (1 ≤ d ≤ m + n) indicates the Manhattan distance. Subsequent n lines of m integers are the initial ON/OFF states. Each Sij (1 ≤ i ≤ n, 1 ≤ j ≤ m) indicates the initial ON/OFF state of the light of the room at (i, j): '0' for OFF and '1' for ON.
The end of the input is indicated by a line containing three zeros.
Output
For each dataset, output '1' if all the lights can be turned off. If not, output '0'. In either case, print it in one line for each input dataset.
Example
Input
1 1 1
1
2 2 1
1 1
1 1
3 2 1
1 0 1
0 1 0
3 3 1
1 0 1
0 1 0
1 0 1
4 4 2
1 1 0 1
0 0 0 1
1 0 1 1
1 0 0 0
5 5 1
1 1 1 0 1
0 1 0 1 0
1 0 1 0 1
0 1 0 1 0
1 0 1 0 1
5 5 2
0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0
11 11 3
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
11 11 3
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 1 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
13 13 7
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0
Output
1
1
0
1
0
0
1
1
0
1
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
template<class T> inline T sqr(T x) {return x*x;}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#define each(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define exist(s,e) ((s).find(e)!=(s).end())
#define range(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) range(i,0,n)
#define clr(a,b) memset((a), (b) ,sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
const double eps = 1e-10;
const double pi = acos(-1.0);
const ll INF =1LL << 62;
const int inf =1 << 29;
typedef valarray<int> vec;
typedef valarray<vec> mat;
bool check(mat &a){
int n=a.size(),m=a[0].size();
int r=0,c=0;
rep(i,n-1){
int index=-1;
while(c<m&&index==-1){
range(j,i,n) if(a[j][c]) index=j;
if(index==-1)
c++;
else if(i!=index)
swap(a[i],a[index]);
}
if(index==-1) break;
range(j,i+1,n){
int d=a[j][c]/a[i][c];
range(k,c,m){
a[j][k]+=a[i][k]*d;
a[j][k]%=2;
}
}
c++;
}
int rank=0,add=0;
r=0,c=0;
while(r<n&&c<m-1){
while(c<m-1&&a[r][c]==0) c++;
if(c==m-1) break;
rank++,r++;
while(r<n&&a[r][c]!=0) r++;
if(r==n) break;
}
if(r<n) range(i,r,n) if(a[i][m-1]!=0) add=1;
return !add;
}
int main(void){
int m,n,d;
while(cin >> m >> n >> d){
int num=m*n;
if(num==0) break;
mat state(vec(0,num+1),num);
rep(i,n)rep(j,m){
int row=i*m+j;
rep(a,n)rep(b,m){
int col=a*m+b;
int dist=abs(i-a)+abs(j-b);
if(dist==d) state[row][col]=1;
}
state[row][row]=1;
cin >> state[row][num];
}
cout << check(state) << endl;
}
return 0;
}
|
Problem
Aizu Magic School is a school where people who can use magic gather. Haruka, one of the students of that school, can use the magic of warp on the magic team.
From her house to the school, there is a straight road of length L. There are also magic circles on this road.
She uses this road every day to go to school, so she wants to get to school in the shortest possible time.
So as a programmer, you decided to teach her the minimum amount of time it would take to get to school.
Haruka can walk forward by a distance of 1 in 1 minute (* cannot go back). Also, by casting magic at the position Pi where the magic circle of the warp is written, you can move in Ti minutes to the place just Di from Pi. Even if there is a magic circle at the destination, it will be continuous. You can use warp magic.
The location of her house is 0 and the location of her school is L.
Constraints
The input meets the following conditions.
* All numbers given are integers
* 1 ≤ L ≤ 109
* 0 ≤ n ≤ min (103, L) (min represents the smaller of A and B)
* 0 ≤ Pi ≤ L -1
* 0 ≤ Di ≤ L --Pi
* 0 ≤ Ti ≤ 103
* Pi ≠ Pj
Input
L n
P1 D1 T1
P2 D2 T2
..
..
Pn Dn Tn
The first line is given the length of the road L, the number of magic circles n. Next, the state of n magic circles is given. Pi is the position where the i-th magic circle is, and Di is the i-th magic circle. Distance to warp from, Ti represents the time it takes to warp using the i-th magic circle.
Output
Output the minimum time to get to school in one line.
Examples
Input
10 3
2 2 1
4 2 1
8 1 1
Output
8
Input
10 2
2 3 1
3 5 1
Output
6
Input
1 0
Output
1
|
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
using namespace std;
typedef long long ll;
const static int tx[] = {+0,+1,+0,-1};
const static int ty[] = {-1,+0,+1,+0};
static const double EPS = 1e-12;
class MagicalCircle{
public:
int pos;
int dist;
int time;
MagicalCircle(int _p,int _d,int _t) : pos(_p),dist(_d),time(_t){}
bool operator<(const MagicalCircle& m) const{
return pos < m.pos;
}
bool operator>(const MagicalCircle& m) const{
return pos > m.pos;
}
bool operator<(const int num) const{
return pos < num;
}
bool operator>(const int num) const{
return pos > num;
}
};
class State{
public:
int pos;
int time;
State(int _p,int _t) : pos(_p),time(_t){}
bool operator<(const State& s) const{
return time < s.time;
}
bool operator>(const State& s) const{
return time > s.time;
}
};
int main(){
int distance;
int total_magical_circles;
while(~scanf("%d %d",&distance,&total_magical_circles)){
vector<MagicalCircle> magical_circles;
for(int circle_idx=0;circle_idx<total_magical_circles;circle_idx++){
int pos;
int dist;
int time;
scanf("%d %d %d",&pos,&dist,&time);
magical_circles.push_back(MagicalCircle(pos,dist,time));
}
magical_circles.push_back(MagicalCircle(distance,0,0));
sort(magical_circles.begin(),magical_circles.end());
priority_queue<State,vector<State>,greater<State> > que;
que.push(State(0,0));
map<int,int> dp;
while(!que.empty()){
State s = que.top();
que.pop();
if(dp.find(s.pos) != dp.end()) continue;
dp[s.pos] = s.time;
int idx = lower_bound(magical_circles.begin(),magical_circles.end(),s.pos) - magical_circles.begin();
if(magical_circles[idx].pos == s.pos){
//use
int next_time = s.time + magical_circles[idx].time;
int next_pos = s.pos + magical_circles[idx].dist;
que.push(State(next_pos,next_time));
//un-use
int next_time2 = s.time + 1;
int next_pos2 = s.pos + 1;
que.push(State(next_pos2,next_time2));
}
else{
//just move
int next_time = s.time + (magical_circles[idx].pos - s.pos);
int next_pos = magical_circles[idx].pos;
que.push(State(next_pos,next_time));
}
}
printf("%d\n",dp[distance]);
}
}
|
Divisor is the Conquerer is a solitaire card game. Although this simple game itself is a great way to pass one’s time, you, a programmer, always kill your time by programming. Your task is to write a computer program that automatically solves Divisor is the Conquerer games. Here is the rule of this game:
First, you randomly draw N cards (1 ≤ N ≤ 52) from your deck of playing cards. The game is played only with those cards; the other cards will not be used.
Then you repeatedly pick one card to play among those in your hand. You are allowed to choose any card in the initial turn. After that, you are only allowed to pick a card that conquers the cards you have already played. A card is said to conquer a set of cards when the rank of the card divides the sum of the ranks in the set. For example, the card 7 conquers the set {5, 11, 12}, while the card 11 does not conquer the set {5, 7, 12}.
You win the game if you successfully play all N cards you have drawn. You lose if you fails, that is, you faces a situation in which no card in your hand conquers the set of cards you have played.
Input
The input consists of multiple test cases.
Each test case consists of two lines. The first line contains an integer N (1 ≤ N ≤ 52), which represents the number of the cards. The second line contains N integers c1 , . . . , cN (1 ≤ ci ≤ 13), each of which represents the rank of the card. You may assume that there are at most four cards with the same rank in one list.
The input is terminated by a line with a single zero.
Output
For each test case, you should output one line. If there are any winning strategies for the cards of the input, print any one of them as a list of N integers separated by a space.
If there is no winning strategy, print “No”.
Example
Input
5
1 2 3 3 7
4
2 3 3 3
0
Output
3 3 1 7 2
No
|
#include <iostream>
#include <cstring>
using namespace std;
#define REP(i,n,m) for(int i=n;i<m;i++)
#define rep(i,n) REP(i,0,n)
int n,cnt[14],ans[54];
bool solve(int idx,int sum){
if(idx == 0 && sum == 0) return true;
if(idx < 0 || sum < 0) return false;
rep(i,14){
if(cnt[i]>0 && (sum - i) % i == 0){
ans[idx-1] = i;
cnt[i]--;
if(solve(idx-1,sum-i)) return true;
cnt[i]++;
}
}
return false;
}
int main(void){
while(cin>>n,n){
int sum = 0;
memset(cnt,0,sizeof(cnt));
rep(i,n){
int x;
cin>>x;
sum += x;
cnt[x]++;
}
bool flg = solve(n,sum);
if(flg){
rep(i,n-1) cout<<ans[i]<<" ";
cout<<ans[n-1]<<endl;
}
else{
cout<<"No\n";
}
}
return 0;
}
|
A small country called Maltius was governed by a queen. The queen was known as an oppressive ruler. People in the country suffered from heavy taxes and forced labor. So some young people decided to form a revolutionary army and fight against the queen. Now, they besieged the palace and have just rushed into the entrance.
Your task is to write a program to determine whether the queen can escape or will be caught by the army.
Here is detailed description.
* The palace can be considered as grid squares.
* The queen and the army move alternately. The queen moves first.
* At each of their turns, they either move to an adjacent cell or stay at the same cell.
* Each of them must follow the optimal strategy.
* If the queen and the army are at the same cell, the queen will be caught by the army immediately.
* If the queen is at any of exit cells alone after the army’s turn, the queen can escape from the army.
* There may be cases in which the queen cannot escape but won’t be caught by the army forever, under their optimal strategies.
Hint
On the first sample input, the queen can move to exit cells, but either way the queen will be caught at the next army’s turn. So the optimal strategy for the queen is staying at the same cell. Then the army can move to exit cells as well, but again either way the army will miss the queen from the other exit. So the optimal strategy for the army is also staying at the same cell. Thus the queen cannot escape but won’t be caught.
Input
The input consists of multiple datasets. Each dataset describes a map of the palace. The first line of the input contains two integers W (1 ≤ W ≤ 30) and H (1 ≤ H ≤ 30), which indicate the width and height of the palace. The following H lines, each of which contains W characters, denote the map of the palace. "Q" indicates the queen, "A" the army,"E" an exit,"#" a wall and "." a floor.
The map contains exactly one "Q", exactly one "A" and at least one "E". You can assume both the queen and the army can reach all the exits.
The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.
Output
For each dataset, output "Queen can escape.", "Army can catch Queen." or "Queen can not escape and Army can not catch Queen." in a line.
Examples
Input
2 2
QE
EA
3 1
QAE
3 1
AQE
5 5
..E..
.###.
A###Q
.###.
..E..
5 1
A.E.Q
5 5
A....
####.
..E..
.####
....Q
0 0
Output
Queen can not escape and Army can not catch Queen.
Army can catch Queen.
Queen can escape.
Queen can not escape and Army can not catch Queen.
Army can catch Queen.
Army can catch Queen.
Input
2 2
QE
EA
3 1
QAE
3 1
AQE
5 5
..E..
.###.
A###Q
.###.
..E..
5 1
A.E.Q
5 5
A....
.
..E..
.####
....Q
0 0
Output
Queen can not escape and Army can not catch Queen.
Army can catch Queen.
Queen can escape.
Queen can not escape and Army can not catch Queen.
Army can catch Queen.
Army can catch Queen.
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcountll
#define INF 1e16
#define mod 1000000007
int W,H;
string s[33];
int ai,aj,qi,qj;
int st[33][33][33][33][2];
int rest[33][33][33][33][2];
int dd[]={-1,0,0,1,0,-1};
struct state{
int qi,qj,ai,aj,t;
};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
while(1){
cin>>W>>H;
if(W==0)break;
rep(i,H){
cin>>s[i];
rep(j,W){
if(s[i][j]=='A'){
ai=i; aj=j;
}
if(s[i][j]=='Q'){
qi=i; qj=j;
}
}
}
memset(st,-1,sizeof(st));
memset(rest,0,sizeof(rest));
queue<state> que;
rep(sqi,H)rep(sqj,W)rep(sai,H)rep(saj,W)rep(tt,2){
if(s[sqi][sqj]=='#'||s[sai][saj]=='#')continue;
if(s[sqi][sqj]=='E'&&!(sqi==sai&&sqj==saj)&&tt==0){
que.push((state){sqi,sqj,sai,saj,tt});
st[sqi][sqj][sai][saj][tt]=1;
}else if(sqi==sai&&sqj==saj){
que.push((state){sqi,sqj,sai,saj,tt});
st[sqi][sqj][sai][saj][tt]=0;
}else if(tt==0){
rep(d,5){
int nqi=sqi+dd[d],nqj=sqj+dd[d+1];
if(nqi<0||nqi>=H||nqj<0||nqj>=W||s[nqi][nqj]=='#')continue;
rest[sqi][sqj][sai][saj][tt]++;
}
}else if(tt==1){
rep(d,5){
int nai=sai+dd[d],naj=saj+dd[d+1];
if(nai<0||nai>=H||naj<0||naj>=W||s[nai][naj]=='#')continue;
rest[sqi][sqj][sai][saj][tt]++;
}
}
}
while(que.size()){
state c=que.front(); que.pop();
int crtst=st[c.qi][c.qj][c.ai][c.aj][c.t];
if(c.t==1){
rep(d,5){
int nqi=c.qi+dd[d],nqj=c.qj+dd[d+1];
if(nqi<0||nqi>=H||nqj<0||nqj>=W||s[nqi][nqj]=='#'||
st[nqi][nqj][c.ai][c.aj][1-c.t]!=-1)continue;
if(crtst==1){
que.push((state){nqi,nqj,c.ai,c.aj,1-c.t});
st[nqi][nqj][c.ai][c.aj][1-c.t]=1;
continue;
}
rest[nqi][nqj][c.ai][c.aj][1-c.t]--;
if(rest[nqi][nqj][c.ai][c.aj][1-c.t]==0){
que.push((state){nqi,nqj,c.ai,c.aj,1-c.t});
st[nqi][nqj][c.ai][c.aj][1-c.t]=0;
}
}
}else if(c.t==0){
rep(d,5){
int nai=c.ai+dd[d],naj=c.aj+dd[d+1];
if(nai<0||nai>=H||naj<0||naj>=W||s[nai][naj]=='#'||
st[c.qi][c.qj][nai][naj][1-c.t]!=-1)continue;
if(crtst==0){
que.push((state){c.qi,c.qj,nai,naj,1-c.t});
st[c.qi][c.qj][nai][naj][1-c.t]=0;
continue;
}
rest[c.qi][c.qj][nai][naj][1-c.t]--;
if(rest[c.qi][c.qj][nai][naj][1-c.t]==0){
que.push((state){c.qi,c.qj,nai,naj,1-c.t});
st[c.qi][c.qj][nai][naj][1-c.t]=1;
}
}
}
}
if(st[qi][qj][ai][aj][0]==-1)cout<<"Queen can not escape and Army can not catch Queen."<<endl;
if(st[qi][qj][ai][aj][0]==0) cout<<"Army can catch Queen."<<endl;
if(st[qi][qj][ai][aj][0]==1) cout<<"Queen can escape."<<endl;
}
return 0;
}
|
There is an evil creature in a square on N-by-M grid (2 \leq N, M \leq 100), and you want to kill it using a laser generator located in a different square. Since the location and direction of the laser generator are fixed, you may need to use several mirrors to reflect laser beams. There are some obstacles on the grid and you have a limited number of mirrors. Please find out whether it is possible to kill the creature, and if possible, find the minimum number of mirrors.
There are two types of single-sided mirrors; type P mirrors can be placed at the angle of 45 or 225 degrees from east-west direction, and type Q mirrors can be placed with at the angle of 135 or 315 degrees. For example, four mirrors are located properly, laser go through like the following.
<image>
Note that mirrors are single-sided, and thus back side (the side with cross in the above picture) is not reflective. You have A type P mirrors, and also A type Q mirrors (0 \leq A \leq 10). Although you cannot put mirrors onto the squares with the creature or the laser generator, laser beam can pass through the square. Evil creature is killed if the laser reaches the square it is in.
Input
Each test case consists of several lines.
The first line contains three integers, N, M, and A. Each of the following N lines contains M characters, and represents the grid information. '#', '.', 'S', 'G' indicates obstacle, empty square, the location of the laser generator, and the location of the evil creature, respectively. The first line shows the information in northernmost squares and the last line shows the information in southernmost squares. You can assume that there is exactly one laser generator and exactly one creature, and the laser generator emits laser beam always toward the south.
Output
Output the minimum number of mirrors used if you can kill creature, or -1 otherwise.
Examples
Input
3 3 2
S#.
...
.#G
Output
2
Input
3 3 1
S#.
...
.#G
Output
-1
Input
3 3 1
S#G
...
.#.
Output
2
Input
4 3 2
S..
...
..#
.#G
Output
-1
|
#include<iostream>
#include<string.h>
#include<queue>
#define inf 1000000001
using namespace std;
int X[4]={0,1,0,-1};
int Y[4]={-1,0,1,0};
int H,W,A,si,sj;
char map[100][100];
bool in(int y,int x){
if(y<0 || x<0 || y>=H || x>=W)return false;
return true;
}
class State{
public:
int y,x,muki,numL,numR;
State(int y,int x,int muki,int l,int r):y(y),x(x),muki(muki),numL(l),numR(r){}
};
int main()
{
int memo[100][100][4];
for(int i=0;i<100;i++){
for(int j=0;j<100;j++){
for(int k=0;k<4;k++)memo[i][j][k]=inf;
}
}
queue<State> Q;
cin>>H>>W>>A;
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
cin>>map[i][j];
if(map[i][j]=='S'){
si=i;
sj=j;
map[i][j]='.';
}
}
}
Q.push(State(si,sj,2,0,0));
memo[si][sj][0]=0;
memo[si][sj][2]=0;
int ans=inf;
int a,b;
while(!Q.empty()){
State u=Q.front();
//cout<<u.y<<" "<<u.x<<" "<<u.muki<<" "<<u.numL<<" "<<u.numR<<endl;
Q.pop();
if(u.numL>A || u.numR>A)continue;
if(map[u.y][u.x]=='G'){
ans=min(memo[u.y][u.x][u.muki],ans);
continue;
}
a=u.y+Y[u.muki];
b=u.x+X[u.muki];
if(in(a,b)){
if(map[a][b]!='#'){
if(memo[a][b][u.muki]>=u.numL+u.numR){
memo[a][b][u.muki]=u.numL+u.numR;
Q.push(State(a,b,u.muki,u.numL,u.numR));
}
}
}
if(u.y==si && u.x==sj){}
else {
a=u.y+Y[(u.muki+1)%4];
b=u.x+X[(u.muki+1)%4];
if(in(a,b)){
if(map[a][b]!='#'){
if(memo[a][b][(u.muki+1)%4]>=u.numL+u.numR+1){
memo[a][b][(u.muki+1)%4]=u.numR+u.numL+1;
if(memo[a][b][(u.muki+1)%4]<ans){
if(((u.muki+1)%4)%2==0){
if(u.numL<A)Q.push(State(a,b,(u.muki+1)%4,u.numL+1,u.numR));
}
if(((u.muki+1)%4)%2==1){
if(u.numR<A)Q.push(State(a,b,(u.muki+1)%4,u.numL,u.numR+1));
}
}
}
}
}
a=u.y+Y[(u.muki+3)%4];
b=u.x+X[(u.muki+3)%4];
if(in(a,b)){
if(map[a][b]!='#'){
if(memo[a][b][(u.muki+3)%4]>=u.numR+u.numL+1){
memo[a][b][(u.muki+3)%4]=u.numR+u.numL+1;
if(memo[a][b][(u.muki+3)%4]<ans){
if(((u.muki+3)%4)%2==0){
if(u.numR<A)Q.push(State(a,b,(u.muki+3)%4,u.numL,u.numR+1));
}
if(((u.muki+3)%4)%2==1){
if(u.numL<A)Q.push(State(a,b,(u.muki+3)%4,u.numL+1,u.numR));
}
}
}
}
}
}
}
if(ans==inf)cout<<-1<<endl;
else cout<<ans<<endl;
return 0;
}
|
K-th String
Problem Statement
The suffix array SA for the character string S of length N is defined as a permutation of positive integers of N or less obtained by the following procedure.
The substring from the i-th character to the j-th character of S is expressed as S [i..j]. However, the subscript is 1-indexed.
1. Arrange each suffix S [i..N] (i = 1,2, ..., N) in lexicographic order (ascending order).
2. Arrange the start position i of each of the aligned suffixes in order.
For example, the suffix array SA for S = "mississippi" is as follows.
<image>
As input, the suffix array SA for a string of length N is given.
Find the K-th (1-indexed) string in lexicographic order from which SA can be obtained.
However, the original character string consists of at most A characters counting from'a'in alphabetical order.
Constraints
* 1 ≤ N ≤ 10 ^ 5
* 1 ≤ A ≤ 26
* 1 ≤ K ≤ 10 ^ {18}
* 1 ≤ SA_i ≤ N
* If i \ neq j, then SA_i \ neq SA_j
Input
Input follows the following format. All given numbers are integers.
N A K
SA_1_1
SA_2
...
SA_N
Output
Output the K-th character string on one line in a lexicographic order that gives SA.
If the Kth character string does not exist, output "Impossible".
Examples
Input
3 4 2
2
1
3
Output
bad
Input
18 26 10275802967
10
14
9
13
7
8
2
6
11
18
12
1
4
3
16
5
17
15
Output
ritsumeicampdaytwo
|
#include <set>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long int64;
const int MAX_N = int(1e5 + 10);
const int MAX_K = 30;
const int64 INF = int64(2.05e18); //^@ 2^63 ~ 9.2*10^18。本当にこれで大丈夫？
int N, K;
int64 L;
int sa[MAX_N + 1];
int64 comb[MAX_N + MAX_K + 1][MAX_K + 1];
inline int64 multi(const int64 x, const int64 y) {
return (double(x)*y < INF * 1.3) ? x * y : INF;
}
void init() {
scanf("%d%d%lld", &N, &K, &L);
sa[0] = N;
for (int i = 1; i <= N; ++i) {
scanf("%d", sa + i);
--sa[i];
}
}
void prepareCombination() {
for (int n = 0; n <= N + K; ++n) {
comb[n][0] = 1;
if (n <= K) {
comb[n][n] = 1;
}
for (int k = 1; k <= min(n, K); ++k) {
if (n - 1 >= k) {
comb[n][k] = min(INF, comb[n-1][k] + comb[n-1][k-1]);
}
}
}
}
struct State {
int from, to;
int64 ways;
State(){}
State(int from_, int to_, int64 ways_):
from(from_), to(to_), ways(ways_)
{}
};
void solve() {
prepareCombination();
//inv[i] := str[k..]は辞書順何番目にくるのか。
static int inv[MAX_N + 1];
for (int i = 0; i <= N; ++i) {
inv[sa[i]] = i;
}
//mustInc[i] := sa[i]番目の文字はsa[i-1]番目の文字より大きくなければならないか。
static bool mustInc[MAX_N + 1];
int incCount = 0;
for (int i = 1; i < N; ++i) {
if (inv[sa[i+1] + 1] < inv[sa[i] + 1]) {
mustInc[i] = true;
++incCount;
}
}
//足りない、不可能な場合
K -= incCount;
if (K <= 0 || comb[N+K-1][K-1] < L) {
puts("Impossible");
return ;
}
//fixedAcc[i]: -1ならその文字は未確定。そうでないならaccの累積値がfixedAcc[i]でなくてはならない。
static int fixedAcc[MAX_N + 1];
memset(fixedAcc, -1, sizeof(fixedAcc));
fixedAcc[N] = K - 1;
//意味のある区間の数。statesに含まれる要素は高々K個。
vector<State> states;
states.push_back(State(-1, N, comb[N+K-1][K-1]));
//setを使ってO(n*(log n + A))で手抜く。
set<int> fixed;
fixed.insert(1);
fixed.insert(-N);
for (int _ = 0; _ < N; ++_) {
const int p = inv[_] - 1;
int key = -1;
int64 w = 1;
int prev = -(*fixed.lower_bound(-p));
int lAcc = prev == -1 ? 0 : fixedAcc[prev];
for (int i = 0; i < int(states.size()); ++i) {
if (states[i].from <= p && p <= states[i].to) {
key = i;
}
else {
w = multi(w, states[i].ways);
}
}
if (key == -1) {
fixedAcc[p] = lAcc;
fixed.insert(-p);
continue;
}
const int from = states[key].from, to = states[key].to;
states.erase(states.begin() + key);
for (int a = lAcc; ; ++a) {
int64 leftWay = 1, rightWay = 1;
int leftFlex = a - (from >= 0 ? fixedAcc[from]: 0);
int rightFlex = fixedAcc[to] - a;
if (leftFlex > 0) {
leftWay = comb[p-from-1 + leftFlex][leftFlex];
}
if (rightFlex > 0) {
rightWay = comb[to-p-1 + rightFlex][rightFlex];
}
int64 newWay = multi(leftWay, rightWay);
if (multi(newWay, w) >= L) {
if (leftWay > 1) {
states.push_back(State(from, p, leftWay));
}
if (rightWay > 1) {
states.push_back(State(p, to, rightWay));
}
fixedAcc[p] = a;
fixed.insert(-p);
break;
}
else {
L -= newWay * w;
}
}
}
static char ans[MAX_N + 1];
int add = 0;
for (int i = 0; i < N; ++i) {
if (mustInc[i]) {
++add;
}
ans[sa[i+1]] = char('a' + fixedAcc[i] + add);
}
puts(ans);
}
int main() {
init();
solve();
return 0;
}
|
Problem statement
There is a rooted tree of size N. Each vertex is numbered from 0 to N-1, with a root of 0. For the vertices at both ends of any side, the assigned integer is smaller closer to the root. Initially, the weights of all edges are 0.
Process Q queries on this tree in sequence. There are two types of queries:
* Find the distance between vertices u and v (sum of the weights of the sides contained in the path).
* Increases the weights of all edges connecting to the descendants of vertex v (not including itself) by x.
input
The input consists of the following format.
N Q
a_0 b_0
...
a_ {N−2} b_ {N−2}
q_0
...
q_ {Q−1}
a_i and b_i are the vertices connected by the i-th side. q_i is the three integers that represent the i-th query and is one of the following:
* 0 \ u_i \ v_i: Find the distance between the vertices u_i and v_i.
* 1 \ v_i \ x_i: Increases all the weights of edges connecting to the descendants of vertex v_i by x_i.
Constraint
* All inputs are integers
* 2 \ ≤ N \ ≤ 150 \,000
* 1 \ ≤ Q \ ≤ 150 \,000
* 0 \ ≤ a_ {i}, b_ {i}, u_ {i}, v_ {i} \ ≤ N−1
* a_ {i} <b_ {i}
* 0 \ ≤ x_ {i} \ ≤ 300
output
Print the result in one line for each distance query.
Note
I / O can be very large for this problem, so use a fast function.
sample
Sample input 1
9 6
0 1
0 2
0 3
14
1 5
4 6
5 7
5 8
1 0 1
1 1 2
0 6 3
1 5 5
1 8 4
0 4 3
Sample output 1
8
Five
It looks like the figure.
<image>
Sample input 2
13 7
0 1
1 2
twenty three
14
3 5
1 6
2 7
0 8
7 9
5 10
8 11
1 12
1 2 143
0 8 7
0 10 6
1 1 42
1 6 37
0 3 6
1 6 38
Sample output 2
143
429
269
Example
Input
9 6
0 1
0 2
0 3
1 4
1 5
4 6
5 7
5 8
1 0 1
1 1 2
0 6 3
1 5 5
1 8 4
0 4 3
Output
8
5
|
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define int long long
struct LCA {
int N, logN;
vector<vector<int>> G;
vector<int> depth;
vector<vector<int>> parent;
LCA(int size) : N(size), G(size), depth(size) {
logN = 0;
for(int x = 1; x < N; x *= 2) logN++;
parent.assign(max<int>(logN, 1), vector<int>(N));
}
void add_edge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
void build() {
queue<pair<int, int>> Q;
Q.emplace(0, -1);
while(!Q.empty()) {
pair<int, int> p = Q.front(); Q.pop();
int cur = p.first, prev = p.second;
parent[0][cur] = prev;
if(prev == -1) depth[cur] = 0;
else depth[cur] = depth[prev] + 1;
for(int next : G[cur]) {
if(next != prev) Q.emplace(next, cur);
}
}
for(int k = 1; k < logN; k++) {
for(int v = 0; v < N; v++) {
if(parent[k - 1][v] == -1) parent[k][v] = -1;
else parent[k][v] = parent[k - 1][parent[k - 1][v]];
}
}
}
int lca(int u, int v) {
if(depth[u] > depth[v]) swap(u, v);
for(int k = 0; k < logN; k++) {
if(((depth[v] - depth[u]) >> k) & 1) {
v = parent[k][v];
}
}
if(u == v) return u;
for(int k = logN - 1; k >= 0; k--) {
if(parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
const int sqrtN = 400;
struct SqrtDecomposition {
int N, K;
vector<int> data;
vector<int> addpart;
vector<int> addall;
SqrtDecomposition(int n) : N(n) {
K = (N + sqrtN - 1) / sqrtN;
data.assign(K * sqrtN, 0);
addpart.assign(K, 0);
addall.assign(K, 0);
}
void put(int a, int b, int value) {
for(int k = 0; k < K; ++k) {
int l = k * sqrtN, r = (k + 1) * sqrtN;
if(r <= a || b <= l) continue;
if(a <= l && r <= b) {
addall[k] += value;
}
else {
for(int i = max(a, l); i < min(b, r); ++i) {
data[i] += value;
addpart[k] += value;
}
}
}
}
int get(int a, int b) {
int ret = 0;
for(int k = 0; k < K; ++k) {
int l = k * sqrtN, r = (k + 1) * sqrtN;
if(r <= a || b <= l) continue;
if(a <= l && r <= b) {
ret += addall[k] * sqrtN + addpart[k];
}
else {
for(int i = max(a, l); i < min(b, r); ++i) {
ret += data[i] + addall[k];
}
}
}
return ret;
}
};
const int MAX_N = 150000;
int IN[MAX_N], IN2[MAX_N], OUT[MAX_N], OUT2[MAX_N];
int in, out;
vector<vector<int>> G;
void dfs() {
stack<pair<int, pair<int, int>>> S;
S.push(make_pair(+1, make_pair(0, -1)));
while(!S.empty()) {
pair<int, pair<int, int>> pp = S.top(); S.pop();
int t = pp.first, cur = pp.second.first, prev = pp.second.second;
if(t == +1) {
IN[cur] = in++;
IN2[cur] = out;
S.push(make_pair(-1, make_pair(cur, prev)));
for(int next : G[cur]) {
if(next != prev) {
S.push(make_pair(+1, make_pair(next, cur)));
}
}
}
else {
OUT[cur] = out++;
OUT2[cur] = in;
}
}
}
signed main() {
int N, Q; scanf("%lld %lld", &N, &Q);
G.resize(N);
LCA lca(N);
REP(i,N-1) {
int a, b; scanf("%lld %lld", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
lca.add_edge(a, b);
}
lca.build();
in = 0, out = 0;
dfs();
SqrtDecomposition plus(N);
SqrtDecomposition minus(N);
REP(q,Q) {
int t, a, b; scanf("%lld %lld %lld", &t, &a, &b);
if(!t) {
int c = lca.lca(a, b);
int d1 = plus.get(0, IN[a] + 1) - minus.get(0, IN2[a]);
int d2 = plus.get(0, IN[b] + 1) - minus.get(0, IN2[b]);
int d3 = plus.get(0, IN[c] + 1) - minus.get(0, IN2[c]);
printf("%lld\n", d1+d2-d3*2);
}
else {
plus.put(IN[a] + 1, OUT2[a], b);
minus.put(IN2[a], OUT[a], b);
}
}
}
|
problem
AOR Ika and you came to the tournament-style table tennis tournament singles section for reconnaissance. For AOR Ika-chan, who wants to record all the games, you decide to ask for the number of games that will be played in this tournament.
There are $ N $ players in the tournament, each with a uniform number of $ 0, \ dots, N -1 $. Among them, $ M $ players abstained and did not participate in the match.
The number of games in this tournament will be determined based on the following rules.
* There are no seed players, and the number of wins required for any contestant to win is constant.
* If the opponent is absent, the match will not be played and the player who participated will win. It is not counted in the number of games.
* The tournament will end when the winner is decided.
* A person who loses a match will not play the match again. In other words, there will be no repechage or third place playoff.
* Since there is only one table tennis table, different games will not be played at the same time, and the winner will always be decided in each game (it will not be a draw).
The definition of the tournament is as follows. The tournament is represented by a full binary tree with a height of $ L = \ log_2 N $, and each apex of the leaf has the participant's uniform number written on it. Assuming that the root depth is 0, in the $ i $ round ($ 1 \ le i \ le L $), the players with the numbers written on the children of each vertex of the depth $ L --i $ will play a match. Write the winner's uniform number at the top.
<image>
output
Output the number of games played by the end of this tournament in one line. Also, output a line break at the end.
Example
Input
2 0
Output
1
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define pb emplace_back
typedef long long ll;
typedef pair<int,int> pint;
bool a[1<<10];
int main(){
int n,m,ai;
cin>>n>>m;
rep(i,m){
cin>>ai;
a[n+ai]=true;
}
int cnt=0;
for(int i=2*n-1;i>1;i-=2){
if(!a[i]&&!a[i-1]) ++cnt;
a[i/2]=a[i]&&a[i-1];
}
cout<<cnt<<endl;
return 0;
}
|
problem
There is a light bulb at the grid point $ (x, y) $ that meets $ 1 \ leq x \ leq h, 1 \ leq y \ leq w $.
The power supply is installed at coordinates $ (i + 0.5, j + 0.5) (1 \ leq i <h, 1 \ leq j <w, i + j $ is even) (corrected at 14:21). Coordinates $ When the power supply installed at (i + 0.5, j + 0.5) $ is turned on, the coordinates $ (i, j), (i + 1, j), (i, j + 1), (i + 1) , j + 1) $ 4 $ light bulbs in $ glow.
If you have more than $ 1 $ connected to a power supply with a light bulb on $ (i, j) $, you get $ B_ {i, j} $ cleanliness. You have the total cleanliness. Also, if you turn on each power supply, it costs $ W $ for electricity per $ 1 $.
Turn on some power to maximize "total income-total electricity bill".
output
Output the maximum value of "total income-total electricity bill". Also, output a line break at the end.
Example
Input
4 4 10
100 100 100 100
100 100 100 100
1 100 100 1
1 1 1 1
Output
970
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
struct Dinic{
const Int INF=1LL<<55;
struct edge {
Int to,cap,rev;
edge(){}
edge(Int to,Int cap,Int rev):to(to),cap(cap),rev(rev){}
};
Int n;
vector<vector<edge> > G;
vector<map<Int,int> > M;
vector<Int> level,iter;
Dinic(){}
Dinic(Int sz):n(sz),G(n),M(n),level(n),iter(n){}
void add_edge(Int from,Int to,Int cap){
M[from][to]=G[from].size();
M[to][from]=G[to].size();
G[from].push_back(edge(to,cap,G[to].size()));
// undirected
//G[to].push_back(edge(from,cap,G[from].size()-1));
// directed
G[to].push_back(edge(from,0,G[from].size()-1));
}
void bfs(Int s){
fill(level.begin(),level.end(),-1);
queue<Int> que;
level[s]=0;
que.push(s);
while(!que.empty()){
Int v=que.front();que.pop();
for(Int i=0;i<(Int)G[v].size();i++){
edge &e = G[v][i];
if(e.cap>0&&level[e.to]<0){
level[e.to]=level[v]+1;
que.push(e.to);
}
}
}
}
Int dfs(Int v,Int t,Int f){
if(v==t) return f;
for(Int &i=iter[v];i<(Int)G[v].size();i++){
edge &e=G[v][i];
if(e.cap>0&&level[v]<level[e.to]){
Int d = dfs(e.to,t,min(f,e.cap));
if(d>0){
e.cap-=d;
G[e.to][e.rev].cap+=d;
return d;
}
}
}
return 0;
}
Int flow(Int s,Int t,Int lim){
Int fl=0;
for(;;){
bfs(s);
if(level[t]<0||lim==0) return fl;
fill(iter.begin(),iter.end(),0);
Int f;
while((f=dfs(s,t,lim))>0){
fl+=f;
lim-=f;
}
}
}
Int flow(Int s,Int t){
return flow(s,t,INF);
}
//cap==1 only
bool back_edge(Int s,Int t,Int from, Int to){
for(Int i=0;i<(Int)G[from].size();i++) {
edge& e=G[from][i];
if(e.to==to) {
if(e.cap==0&&flow(from,to,1)==0) {
flow(from,s,1);
flow(t,to,1);
return 1;
}
}
}
return 0;
}
};
//INSERT ABOVE HERE
Int b[55][55];
signed main(){
Int h,w,c;
cin>>h>>w>>c;
for(Int i=0;i<h;i++)
for(Int j=0;j<w;j++)
cin>>b[i][j];
Dinic G(h*w/2+2);
Int S=h*w/2,T=S+1;
Int ans=0;
for(Int i=0;i<h;i++)
for(Int j=0;j<w;j++)
ans+=b[i][j];
for(Int i=0;i+1<h;i++){
if(i&1){
for(Int j=1;j<w/2;j++){
G.add_edge(i*(w/2)+j,T,c);
G.add_edge((i-1)*(w/2)+j-1,i*(w/2)+j,b[i][j*2-1]);
G.add_edge((i-1)*(w/2)+j-0,i*(w/2)+j,b[i][j*2-0]);
G.add_edge((i+1)*(w/2)+j-1,i*(w/2)+j,b[i+1][j*2-1]);
G.add_edge((i+1)*(w/2)+j-0,i*(w/2)+j,b[i+1][j*2-0]);
}
}else{
for(Int j=0;j<w/2;j++){
G.add_edge(S,i*(w/2)+j,c);
if(i==0){
G.add_edge(i*(w/2)+j,T,b[i][j*2+0]);
G.add_edge(i*(w/2)+j,T,b[i][j*2+1]);
}
if(i+2==h){
G.add_edge(i*(w/2)+j,T,b[i+1][j*2+0]);
G.add_edge(i*(w/2)+j,T,b[i+1][j*2+1]);
}
}
if(i!=0){
G.add_edge(i*(w/2),T,b[i][0]);
G.add_edge(i*(w/2)+(w/2)-1,T,b[i][w-1]);
}
if(i+2!=h){
G.add_edge(i*(w/2),T,b[i+1][0]);
G.add_edge(i*(w/2)+(w/2)-1,T,b[i+1][w-1]);
}
}
}
cout<<ans-G.flow(S,T)<<endl;
return 0;
}
|
E: Cut out the sum
problem
Ebi-chan has a sequence (a_1, a_2, ..., a_n). Ebi-chan is worried about the maximum value of the sum of the partial arrays (which may be empty), so please find it. Here, a subarray refers to a continuous subsequence. The sum of empty strings is 0.
In addition, Ebi-chan rewrites this sequence q times, so find this value immediately after each rewrite.
Input format
n q
a_1 a_2 ... a_n
k_1 x_1
...
k_q x_q
Each k_j, x_j (1 \ leq j \ leq q) means rewrite a_ {k_j} to x_j. Note that each rewrite is not independent and the array remains rewritten in subsequent processing.
Constraint
* 1 \ leq n \ leq 10 ^ 5
* 1 \ leq q \ leq 10 ^ 5
* 1 \ leq k_j \ leq n
* | a_i |, | x_j | \ leq 10 ^ 9
Output format
Please output q + 1 line. Output the maximum value of the sum of the subarrays before rewriting on the first line and immediately after the i-th rewrite on the 1 + i line.
Input example 1
5 2
1 2 -3 4 -5
3 3
2 -6
Output example 1
Four
Ten
7
If the subarray (a_l,…, a_r) is represented as a [l, r], the sum of a [1, 4] and a [4, 4] is 4 before rewriting, which is the maximum.
After the first rewrite, the sequence becomes (1, 2, 3, 4, -5), and the maximum sum is 10 of a [1, 4].
After the second rewrite, the sequence becomes (1, -6, 3, 4, -5) and the maximum sum is 7 in a [3, 4].
Input example 2
3 1
-one two Three
1 1
Output example 2
0
1
The sum of the empty strings is 0, which is the maximum before rewriting.
Example
Input
5 2
1 2 -3 4 -5
3 3
2 -6
Output
4
10
7
|
#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
typedef long double D;
typedef complex<D> P;
#define F first
#define S second
const ll MOD=1000000007;
//const ll MOD=998244353;
template<typename T,typename U>istream & operator >> (istream &i,pair<T,U> &A){i>>A.F>>A.S; return i;}
template<typename T>istream & operator >> (istream &i,vector<T> &A){for(auto &I:A){i>>I;} return i;}
template<typename T,typename U>ostream & operator << (ostream &o,const pair<T,U> &A){o<<A.F<<" "<<A.S; return o;}
template<typename T>ostream & operator << (ostream &o,const vector<T> &A){ll i=A.size(); for(auto &I:A){o<<I<<(--i?" ":"");} return o;}
//BEGIN CUT HERE
template <typename T,typename E>
struct SegmentTree{
using F = function<T(T,T)>;
using G = function<T(T,E)>;
using H = function<E(E,E)>;
int n,height;
F f;
G g;
H h;
T ti;
E ei;
vector<T> dat;
vector<E> laz;
SegmentTree(F f,G g,H h,T ti,E ei):
f(f),g(g),h(h),ti(ti),ei(ei){}
void init(int n_){
n=1;height=0;
while(n<n_) n<<=1,height++;
dat.assign(2*n,ti);
laz.assign(2*n,ei);
}
void build(const vector<T> &v){
int n_=v.size();
init(n_);
for(int i=0;i<n_;i++) dat[n+i]=v[i];
for(int i=n-1;i;i--)
dat[i]=f(dat[(i<<1)|0],dat[(i<<1)|1]);
}
inline T reflect(int k){
return laz[k]==ei?dat[k]:g(dat[k],laz[k]);
}
inline void eval(int k){
if(laz[k]==ei) return;
laz[(k<<1)|0]=h(laz[(k<<1)|0],laz[k]);
laz[(k<<1)|1]=h(laz[(k<<1)|1],laz[k]);
dat[k]=reflect(k);
laz[k]=ei;
}
inline void thrust(int k){
for(int i=height;i;i--) eval(k>>i);
}
inline void recalc(int k){
while(k>>=1)
dat[k]=f(reflect((k<<1)|0),reflect((k<<1)|1));
}
void update(int a,int b,E x){
thrust(a+=n);
thrust(b+=n-1);
for(int l=a,r=b+1;l<r;l>>=1,r>>=1){
if(l&1) laz[l]=h(laz[l],x),l++;
if(r&1) --r,laz[r]=h(laz[r],x);
}
recalc(a);
recalc(b);
}
void set_val(int a,T x){
thrust(a+=n);
dat[a]=x;laz[a]=ei;
recalc(a);
}
T query(int a,int b){
thrust(a+=n);
thrust(b+=n-1);
T vl=ti,vr=ti;
for(int l=a,r=b+1;l<r;l>>=1,r>>=1) {
if(l&1) vl=f(vl,reflect(l++));
if(r&1) vr=f(reflect(--r),vr);
}
return f(vl,vr);
}
template<typename C>
int find(int st,C &check,T &acc,int k,int l,int r){
if(l+1==r){
acc=f(acc,reflect(k));
return check(acc)?k-n:-1;
}
eval(k);
int m=(l+r)>>1;
if(m<=st) return find(st,check,acc,(k<<1)|1,m,r);
if(st<=l&&!check(f(acc,dat[k]))){
acc=f(acc,dat[k]);
return -1;
}
int vl=find(st,check,acc,(k<<1)|0,l,m);
if(~vl) return vl;
return find(st,check,acc,(k<<1)|1,m,r);
}
template<typename C>
int find(int st,C &check){
T acc=ti;
return find(st,check,acc,1,0,n);
}
};
//END CUT HERE
struct node{
ll mi,mx,ans,sum;
node(ll a=0,ll b=0,ll c=0,ll d=0):mi(a),mx(b),ans(c),sum(d){}
bool operator == (const node &A){return A.mi==mi && A.mx==mx && A.ans==ans && A.sum==sum;}
};
const ll uku=-1*MOD;
node err=node(MOD,uku,0,0);
int main(){
auto f=[](node a,node b){
return node(min(a.mi,a.sum+b.mi),max(a.mx,a.sum+b.mx),max(max(a.ans,b.ans),a.sum+b.mx-a.mi),a.sum+b.sum);
};
auto g=[](node a,node b){return b==err?a:b;};
auto h=[](node a,node b){return b==err?a:b;};
SegmentTree<node,node> ch(f,g,h,err,err);
ll N,Q;
cin>>N>>Q;
N++;
ch.build(vector<node>(N,node()));
vector<ll> A(N-1);
cin>>A;
for(int i=1;i<=N;i++){ch.update(i,i+1,node(A[i-1],A[i-1],0,A[i-1]));}
cout<<ch.query(0,N).ans<<endl;
while(Q--){
/*for(int i=0;i<N;i++){
node ret=ch.query(i,i+1);
cout<<ret.mi<<" "<<ret.mx<<" "<<ret.ans<<" "<<ret.sum<<endl;
}*/
ll k,x;
cin>>k>>x;
ch.update(k,k+1,node(x,x,0,x));
cout<<ch.query(0,N).ans<<endl;
}
return 0;
}
|
A histogram is made of a number of contiguous bars, which have same width.
For a given histogram with $N$ bars which have a width of 1 and a height of $h_i$ = $h_1, h_2, ... , h_N$ respectively, find the area of the largest rectangular area.
Constraints
* $1 \leq N \leq 10^5$
* $0 \leq h_i \leq 10^9$
Input
The input is given in the following format.
$N$
$h_1$ $h_2$ ... $h_N$
Output
Print the area of the largest rectangle.
Examples
Input
8
2 1 3 5 3 4 2 1
Output
12
Input
3
2 0 1
Output
2
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
template<class S,class T> ostream& operator << (ostream& out,const pair<S,T>& o){ out << "(" << o.first << "," << o.second << ")"; return out; }
template<class T> ostream& operator << (ostream& out,const vector<T> V){ for(int i = 0; i < V.size(); i++){ out << V[i]; if(i!=V.size()-1) out << " ";} return out; }
template<class T> ostream& operator << (ostream& out,const vector<vector<T> > Mat){ for(int i = 0; i < Mat.size(); i++) { if(i != 0) out << endl; out << Mat[i];} return out; }
template<class S,class T> ostream& operator << (ostream& out,const map<S,T> mp){ out << "{ "; for(auto it = mp.begin(); it != mp.end(); it++){ out << it->first << ":" << it->second; if(mp.size()-1 != distance(mp.begin(),it)) out << ", "; } out << " }"; return out; }
/*
<url:http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DPL_3_C&lang=jp>
問題文============================================================
=================================================================
解説=============================================================
================================================================
*/
struct Rectangle {
ll h;
ll p; // position from left
};
ll max_area_of_histgram(ll n, vector<ll>& height) {
stack<Rectangle> S;
ll maxv = 0;
for (int i = 0; i <= n; i++) {
Rectangle rect;
rect.h = height[i];
rect.p = i;
if (S.empty()) {
S.push(rect);
}
else if (S.top().h < rect.h) {
S.push(rect);
}
else if (S.top().h > rect.h) {
ll now = i;
while ((!S.empty()) && (S.top().h >= rect.h)) {
Rectangle pre = S.top(); S.pop();
ll area = 1LL * pre.h * (i - pre.p);
maxv = max(maxv, area);
now = pre.p;
}
rect.p = now;
S.push(rect);
}
}
return maxv;
}
ll solve(){
ll N; cin >> N;
vector<ll> dp(N,0); for(auto& in:dp) cin >> in;
dp.push_back(0);
return max_area_of_histgram(N, dp);
}
int main(void) {
cin.tie(0); ios_base::sync_with_stdio(false);
cout << solve() << endl;
return 0;
}
|
Difference of Big Integers
Given two integers $A$ and $B$, compute the difference, $A - B$.
Input
Two integers $A$ and $B$ separated by a space character are given in a line.
Output
Print the difference in a line.
Constraints
* $-1 \times 10^{100000} \leq A, B \leq 10^{100000}$
Sample Input 1
5 8
Sample Output 1
-3
Sample Input 2
100 25
Sample Output 2
75
Sample Input 3
-1 -1
Sample Output 3
0
Sample Input 4
12 -3
Sample Output 4
15
Example
Input
5 8
Output
-3
|
A, B = map(int, input().split())
print(A - B)
|
Most problems on CodeChef highlight chef's love for food and cooking but little is known about his love for racing sports. He is an avid Formula 1 fan. He went to watch this year's Indian Grand Prix at New Delhi. He noticed that one segment of the circuit was a long straight road. It was impossible for a car to overtake other cars on this segment. Therefore, a car had to lower down its speed if there was a slower car in front of it. While watching the race, Chef started to wonder how many cars were moving at their maximum speed.
Formally, you're given the maximum speed of N cars in the order they entered the long straight segment of the circuit. Each car prefers to move at its maximum speed. If that's not possible because of the front car being slow, it might have to lower its speed. It still moves at the fastest possible speed while avoiding any collisions. For the purpose of this problem, you can assume that the straight segment is infinitely long.
Count the number of cars which were moving at their maximum speed on the straight segment.
Input
The first line of the input contains a single integer T denoting the number of test cases to follow. Description of each test case contains 2 lines. The first of these lines contain a single integer N, the number of cars. The second line contains N space separated integers, denoting the maximum speed of the cars in the order they entered the long straight segment.
Output
For each test case, output a single line containing the number of cars which were moving at their maximum speed on the segment.
Example
Input:
3
1
10
3
8 3 6
5
4 5 1 2 3
Output:
1
2
2
Constraints
1 ≤ T ≤ 100
1 ≤ N ≤ 10,000
All speeds are distinct positive integers that fit in a 32 bit signed integer.
Each input file will not be larger than 4 MB (4,000,000,000 bytes) in size.
WARNING! The input files are very large. Use faster I/O.
|
# cook your code here
for testcases in xrange(int(raw_input() ) ) :
n = int(raw_input())
Arr = map(int, raw_input().split() )
m = Arr[0]
c = 1
for i in xrange(1, len(Arr)):
if (Arr[i] <= m ):
c += 1
m = Arr[i]
print c
|
Seeing the current political scenario in the city of Delhi,and the clean sweep of the Aam Aadmi Party, you are wondering that its maybe time to change careers and start selling broomsticks.
Now you sell broomsticks of various lengths. You initially do not have any brooms.You decide to roam about in the city finding brooms and selling them.
During each of the n days of your work as a brooms seller one of the following two events will happen:
1) You may find a broom of length L.You may or may not keep it.
2) You may have a customer ask for a broom of length L.You sell broomsticks by the length.Hence if you have the required broom of length L you can sell it in L rupees.
The only problem is that you have a bad memory hence cant remember the sizes of more than 1 broom hence you never keep more than 1 broom with yourself.
Now if you are given the events of those n days in advance, write a program to figure out the maximum amount you can earn..
Input
The first line contains an integer n denoting the number of days.Each of the next n lines contain the description of the event on the particular day. If you find a broom of length L it contains "found" followed by a blank space and then the integer L.If you have a customer demanding broom of length L then it contains "demand" followed by a blank space and then the integer L..
Output
Output the maximum amount of money that you can earn in rupees if you know the input schedule of events in advance.
Constraints
1 ≤ n ≤ 10000
1 ≤ L ≤ 100000
Example
Input:
4
found 3
found 4
demand 3
demand 4
Output:
4
Explanation
If you choose to keep the broom of length 4 and sell it you can make a profit of Rupees 4 which is also the maximum profit that can be made
|
t=int(input())
ans=0
l=[-1]*(100001)
while(t>0):
s=raw_input().split(" ")
x=int(s[1])
if(s[0]=="found"):
l[x]=ans
elif(l[x]>=0):
ans=max(ans,l[x]+x)
l[x]-=1
t-=1
print ans
|
Sherlock is stuck. There is a N X N grid in which some cells are empty (denoted by ‘.’), while some cells have rocks in them (denoted by ‘#’). Sherlock is on the South of the grid. He has to watch what is happening on the East of the grid. He can place a mirror at 45 degrees on an empty cell in the grid, so that he'll see what is happening on East side by reflection from the mirror.
But, if there's a rock in his line of sight, he won't be able to see what's happening on East side. For example, following image shows all possible cells in which he can place the mirror.
You have to tell Sherlock in how many possible cells he can place the mirror and see what's happening on East side.
Input
First line, T, the number of testcases. Each testcase will consist of N in one line. Next N lines each contain N characters.
Output
For each testcase, print the number of possible options where mirror can be placed to see on the East side.
Constraints
1 ≤ T ≤ 10
1 ≤ N ≤ 1000
Example
Input:
2
3
#..
#..
#..
3
#.#
#.#
#.#
Output:
6
0
Explanation
Example case 1. All places where rock are not there are valid positions.
Example case 2. No valid positions.
Note: Large input data. Use fast input/output.
Time limit for PYTH and PYTH 3.1.2 has been set 8s.
|
def proc(a):
n=len(a)
j=n-1
l=0
ans=0
hsh=[True]*n
for j in range(n-1,-1,-1):
i=n-1
flag=True
while i>=0:
if a[i][j]=='#':
hsh[i]=False
flag=False
elif hsh[i] and flag: ans+=1
i-=1
print ans
t=int(input())
for ii in range(t):
n=int(input())
a=[ raw_input() for i in range(n)]
proc(a)
|
A new school in Byteland is now in the process of renewing some classrooms with new, stronger and better chairs, so that the students can stay still and pay attention to class :)
However, due to budget and logistic reasons, it's only possible to carry a chair at a time to the classroom, which means that for a long time, many students will be up, waiting for their chair to arrive.
The teacher, however, as she is very clever, decided to challenge her students with a problem: "Imagine that there are N students in the classroom and that there are only K chairs. In how many ways, can I choose K elements from the class to sit down, if I see them as being distinct?"
Lira replied immediately with the right answer, so, the teacher decided to make the game a little funnier: "Okay Lira, as you are so fast, now I want you to tell me exactly the same thing, but, with the addition that the value of K is changing, this is, I want you to tell me the sum of the number of ways I can sit down K of you, if the value of K goes from 1 (meaning that there are no chairs in the classroom but one) to N (meaning that all of your chairs arrived). Can you be as fast now? As the answer might get large I want you to tell me the result modulo 1000000007. (10^9 + 7)"
As you might have noticed, it's time for you to help Lira solving this variant of the problem. :D
Input
The first line of the input file contains an integer T, denoting the number of test cases on the input file.
Afterwards, T lines follow, each containing an integer N, the number of students that the teacher will try to sit down as the number of chairs goes from 1 to N.
Output
For each test case, you should output an integer, denoting the sum of the number of ways the teacher can make N students sit down on K chairs, as K goes from 1 to N, modulo 10^9 + 7.
Constraints
1 ≤ T ≤ 100
1 ≤ N ≤ 100000000
Example
Input:
2
1
2
Output:
1
3
|
t=input()
while t>0:
n=input()
print pow(2,n,1000000007)-1
t-=1
|
EDIT : Please note that the user enters the whole string "Energy Level: 217" instead of just 217. You'd have to input accordingly. The output should only be the ids of radioactive elements, one id per line. Stick to the input/output format.
Note: For Turbo C++, select "Text" as your language
Problem description:
After the nuclear war the world is now radioactive. Scientists say if we are not able to track the radioactive element within 30 mins, the human life as we know it, will be extinct. From element survey machines all over the world, we have collected some data. The data contains the energy levels of elements though multiple surveys. The elements with energy level more than 200 might be radioactive. The data is overwhelming, it has so many files that it cannot be read through by any human in so less amount of time. NASA has hired you to find the element.
Input
The first line contains an integer N - denoting the number of elements. The description of these elements follows in the next N lines.
Output
Output the IDs of the elements that might be radioactive.
Constraints
Should contain all the constraints on the input data that you may have. Format it like:
1 ≤ N ≤ 100
1 ≤ Energy Level ≤ 1000
Example1
Input:
3
Energy Level: 20
Energy Level: 200
Energy Level: 201
Output:
3
Example2
Input:
4
Energy Level: 217
Energy Level: 246
Energy Level: 4
Energy Level: 349
Output:
1
2
4
Explanation
Example 1: The first and second element are at energy levels 20, 200 respectively i.e not radioactive. While the third one is at energy level 201, which is radioactive.
Example 2: The first, second and fourth exceed energy level of 200.
|
for u in range(input()):
string = raw_input().split()
if int(string[-1]) > 200:
print u + 1
|
Given a complete binary tree with the height of H, we index the nodes respectively top-down and left-right from 1. The i-th node stores a positive integer Vi. Define Pi as follows: Pii if the i-th node is a leaf, otherwise Pii*PL, Vi*PR), where L and R are the indices of the left and right children of i, respectively. Your task is to caculate the value of P1.
Input
There are several test cases (fifteen at most), each formed as follows:
The first line contains a positive integer H (H ≤ 15).
The second line contains 2^H-1 positive integers (each having a value of 10^9 at most), the i-th integer shows the value of Vi.
The input is ended with H = 0.
Output
For each test case, output on a line an integer which is the respective value of P1 found, by modulo of 1,000,000,007.
Example
Input:
2
1 2 3
3
3 1 5 2 6 4 7
0
Output:
3
105
Explanation:
The second test case is constructed as follows:
3
/ \
/ \
1 5
/ \ / \
2 6 4 7
|
# tree product - trproduct.py
try:
import psyco
psyco.full()
except ImportError:
pass
mod = 1000000007
h = int(raw_input())
while h>0:
v = map(int, raw_input().split())
if h>1:
level = 1<<(h-2)
while level>=1:
for i in xrange(level-1, 2*level-1):
v[i] *= max( v[2*i+1], v[2*i+2] )
# when level=1
# i from [0,1)
level >>= 1
print v[0] % 1000000007
h = int(raw_input())
|
You received a notebook which is called Death Note. This notebook has infinite number of pages. A rule is written on the last page (huh) of this notebook. It says: "You have to write names in this notebook during n consecutive days. During the i-th day you have to write exactly a_i names.". You got scared (of course you got scared, who wouldn't get scared if he just receive a notebook which is named Death Note with a some strange rule written in it?).
Of course, you decided to follow this rule. When you calmed down, you came up with a strategy how you will write names in the notebook. You have calculated that each page of the notebook can contain exactly m names. You will start writing names from the first page. You will write names on the current page as long as the limit on the number of names on this page is not exceeded. When the current page is over, you turn the page. Note that you always turn the page when it ends, it doesn't matter if it is the last day or not. If after some day the current page still can hold at least one name, during the next day you will continue writing the names from the current page.
Now you are interested in the following question: how many times will you turn the page during each day? You are interested in the number of pages you will turn each day from 1 to n.
Input
The first line of the input contains two integers n, m (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 10^9) — the number of days you will write names in the notebook and the number of names which can be written on each page of the notebook.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i means the number of names you will write in the notebook during the i-th day.
Output
Print exactly n integers t_1, t_2, ..., t_n, where t_i is the number of times you will turn the page during the i-th day.
Examples
Input
3 5
3 7 9
Output
0 2 1
Input
4 20
10 9 19 2
Output
0 0 1 1
Input
1 100
99
Output
0
Note
In the first example pages of the Death Note will look like this [1, 1, 1, 2, 2], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [3, 3, 3, 3]. Each number of the array describes during which day name on the corresponding position will be written. It is easy to see that you should turn the first and the second page during the second day and the third page during the third day.
|
(n,m) = tuple(map(int, input().split(" ")))
x = list(map(int, input().split(" ")))
nib = 0
ans = []
cou = 0;
for i in x:
nib+=i
if (nib<m):
ans.append(nib//m)
else:
ans.append(nib//m)
nib-=(nib//m)*m
print (*ans)
|
The average miner Vaganych took refresher courses. As soon as a miner completes the courses, he should take exams. The hardest one is a computer test called "Testing Pants for Sadness".
The test consists of n questions; the questions are to be answered strictly in the order in which they are given, from question 1 to question n. Question i contains ai answer variants, exactly one of them is correct.
A click is regarded as selecting any answer in any question. The goal is to select the correct answer for each of the n questions. If Vaganych selects a wrong answer for some question, then all selected answers become unselected and the test starts from the very beginning, from question 1 again. But Vaganych remembers everything. The order of answers for each question and the order of questions remain unchanged, as well as the question and answers themselves.
Vaganych is very smart and his memory is superb, yet he is unbelievably unlucky and knows nothing whatsoever about the test's theme. How many clicks will he have to perform in the worst case?
Input
The first line contains a positive integer n (1 ≤ n ≤ 100). It is the number of questions in the test. The second line contains space-separated n positive integers ai (1 ≤ ai ≤ 109), the number of answer variants to question i.
Output
Print a single number — the minimal number of clicks needed to pass the test it the worst-case scenario.
Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specificator.
Examples
Input
2
1 1
Output
2
Input
2
2 2
Output
5
Input
1
10
Output
10
Note
Note to the second sample. In the worst-case scenario you will need five clicks:
* the first click selects the first variant to the first question, this answer turns out to be wrong.
* the second click selects the second variant to the first question, it proves correct and we move on to the second question;
* the third click selects the first variant to the second question, it is wrong and we go back to question 1;
* the fourth click selects the second variant to the first question, it proves as correct as it was and we move on to the second question;
* the fifth click selects the second variant to the second question, it proves correct, the test is finished.
|
import java.awt.List;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.*;
public class cool {
private static InputStream stream;
private static PrintWriter pw;
// static int a;
// static int b;
// static int f = 0;
static int n;
static int m;
// static int[][] arr;
//static char[][] arr;
static int Arr[];
static int tree[];
static int time = 0;
static int[][] dir = {{-1,0},{0,1},{1,0},{0,-1}};
static int visited[];
static int visited2[][];
static Stack<Integer> stack;
// static ArrayList<Integer> ans;
// static int arr[][];
// static int arr[];
static char[][] arr;
static char[][] ans;
// static int[][] visited;
// static int c;
// static int d[];
// static int arr[][];
static ArrayList[] adj;
// static ArrayList<Integer> ans;
// static int f;
static int red[];
static int black[];
static int color[];
// static ArrayList<Integer> comp[];
static int f = 0;
static int k = 0;
static int count = 0;
static int total = 0;
static int ini[];
static ArrayList<Node> list;
static ArrayList<Integer> ind;
public static void main(String[] args){
//InputReader(System.in);
pw = new PrintWriter(System.out);
Scanner in = new Scanner(System.in);
int a = in.nextInt();
in.nextLine();
long ans = 0;
for(int i = 0;i<a;i++){
long c = in.nextLong();
ans += c + (c-1)*i;
}
pw.println(ans);
pw.close();
}
public static void dfs(int i){
if(visited[i] == 1)
return;
if(color[i] == 1){
return;
}
visited[i] = 1;
//System.out.println(i);
for(int j = 0;j<adj[i].size();j++){
Node p = (Node)adj[i].get(j);
if(color[p.a-1] == 0){
dfs(p.a-1);
}else{
count = 0;
total = p.b;
bfs(p.a-1);
red[i] += total;
black[i] += count;
}
}
}
public static long ansf(int i){
if(color[i] == 1)
return 0;
if(visited[i] == 1){
return 0;
}
visited[i] = 1;
for(int j = 0;j<adj[i].size();j++){
Node p = (Node)adj[i].get(j);
if(color[p.a-1] == 0 && visited[p.a-1] == 0){
red[i] += ansf(p.a-1) + p.b*black[p.a-1]+ red[p.a-1];
black[i] += black[p.a - 1];
}
}
//System.out.println(red[i] + " reurn;");
return red[i];
}
public static void bfs(int i){
if(visited[i] == 1){
return;
}
if(color[i] == 0){
return;
}
visited[i] = 1;
count++;
//System.out.println(i);
for(int j = 0;j<adj[i].size();j++){
Node p = (Node)adj[i].get(j);
if(color[p.a-1] == 1 && visited[p.a-1] == 0){
//System.out.println(p.b + " l");
total += p.b;
bfs(p.a-1);
}
}
}
public static long pow(long n,long p){
long result = 1;
if(p==0)
return 1;
if (p==1)
return n;
while(p!=0)
{
if(p%2==1)
result *= n;
// if(result>=m)
// result%=m;
p >>=1;
n*=n;
// if(n>=m)
// n%=m;
}
return result;
}
public static int cs(ArrayList<Integer> arr, int low, int high, int x)
{
int mid;
if(x <= arr.get(low))
return low;
if(x > arr.get(high))
return -1;
mid = (low + high)/2;
if(arr.get(mid) == x)
return mid;
else if(arr.get(mid) < x)
{
if(mid + 1 <= high && x <= arr.get(mid+1))
return mid + 1;
else
return cs(arr, mid+1, high, x);
}
else
{
if(mid - 1 >= low && x > arr.get(mid-1))
return mid;
else
return cs(arr, low, mid - 1, x);
}
}
public static int fs(int arr[], int low, int high, int x)
{
if (low > high)
return -1;
if (x >= arr[high])
return high;
// Find the middle point
int mid = (low+high)/2;
// If middle point is floor.
if (arr[mid] == x)
return mid;
// If x lies between mid-1 and mid
if (mid > 0 && arr[mid-1] <= x && x < arr[mid])
return mid-1;
// If x is smaller than mid, floor must be in
// left half.
if (x < arr[mid])
return fs(arr, low, mid-1, x);
// If mid-1 is not floor and x is greater than
// arr[mid],
return fs(arr, mid+1, high, x);
}
public static long gcd(long x, long y) {
if (x == 0)
return y;
else
return gcd( y % x,x);
}
// public static void dfs(int a,int p){
// System.out.println(a);
// if(a > 30000){
// return;
// }
//
// if(visited[a] == 1){
// return;
// }
//
// visited[a] = 1;
//
// if(ini[a] != 0){
// count+= ini[a];
// }
//
// int l = a-p;
//
// if(visited[a+l-1] == 0){
// dfs(a+l-1,a);
// }else if(visited[a+l] == 0){
// dfs(a+l,a);
// }else if(visited[a+l+1] == 0){
// dfs(a+l+1,a);
// }
//
// }
//
public static int prev(int i,boolean[] arr){
while(arr[i]){
if(i == 0){
if(arr[i]){
return -1;
}else{
return 0;
}
}
i--;
}
return i;
}
public static int next(int i,boolean[] arr){
while(arr[i]){
if(i == arr.length-1){
if(arr[i]){
return -1;
}else{
return 0;
}
}
i++;
}
return i;
}
private static Map<String, Integer> sortByValue(Map<String, Integer> unsortMap) {
// 1. Convert Map to List of Map
LinkedList<Entry<String, Integer>> list =
new LinkedList<Map.Entry<String, Integer>>(unsortMap.entrySet());
// 2. Sort list with Collections.sort(), provide a custom Comparator
// Try switch the o1 o2 position for a different order
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
public int compare(Map.Entry<String, Integer> o1,
Map.Entry<String, Integer> o2) {
return (o1.getValue()).compareTo(o2.getValue());
}
});
// 3. Loop the sorted list and put it into a new insertion order Map LinkedHashMap
Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
for (Map.Entry<String, Integer> entry : list) {
sortedMap.put(entry.getKey(), entry.getValue());
}
/*
//classic iterator example
for (Iterator<Map.Entry<String, Integer>> it = list.iterator(); it.hasNext(); ) {
Map.Entry<String, Integer> entry = it.next();
sortedMap.put(entry.getKey(), entry.getValue());
}*/
return sortedMap;
}
public static ArrayList<Integer> Range(int[] numbers, int target) {
int low = 0, high = numbers.length - 1;
// get the start index of target number
int startIndex = -1;
while (low <= high) {
int mid = (high - low) / 2 + low;
if (numbers[mid] > target) {
high = mid - 1;
} else if (numbers[mid] == target) {
startIndex = mid;
high = mid - 1;
} else
low = mid + 1;
}
// get the end index of target number
int endIndex = -1;
low = 0;
high = numbers.length - 1;
while (low <= high) {
int mid = (high - low) / 2 + low;
if (numbers[mid] > target) {
high = mid - 1;
} else if (numbers[mid] == target) {
endIndex = mid;
low = mid + 1;
} else
low = mid + 1;
}
ArrayList<Integer> list = new ArrayList<Integer>();
int c = 0;
if (startIndex != -1 && endIndex != -1){
for(int i = startIndex;i<=endIndex;i++){
list.add(i);
}
}
return list;
}
private static int root(int Arr[],int i)
{
while(Arr[ i ] != i) //chase parent of current element until it reaches root
{
Arr[ i ] = Arr[ Arr[ i ] ] ;
i = Arr[ i ];
}
return i;
}
private static void union(int Arr[],int size[],int A,int B)
{
int root_A = root(Arr,A);
int root_B = root(Arr,B);
System.out.println(root_A + " " + root_B);
if(root_A != root_B){
if(size[root_A] < size[root_B ])
{
Arr[ root_A ] = Arr[root_B];
size[root_B] += size[root_A];
}
else
{
Arr[ root_B ] = Arr[root_A];
size[root_A] += size[root_B];
}
}
}
private static boolean find(int A,int B)
{
if( root(Arr,A)==root(Arr,B) ) //if A and B have the same root, it means that they are connected.
return true;
else
return false;
}
//
// public static void bfs(int i){
//
// Queue<Integer> q=new LinkedList<Integer>();
// q.add(i);
//
// visited[i] = 1;
// c++;
// nodes++;
// while(!q.isEmpty()){
// int top=q.poll();
//
// Iterator<Integer> it= arr[top].listIterator();
// while(it.hasNext()){
// int next =it.next();
//
// if(visited[next] == 0){
// nodes++;
// visited[next] = 1;
// q.add(next);
// }
//
// }
// }
//
// }
// public static void dfs(int i){
//
//
// if(visited[i] == 1){
// return;
// }
//
// visited[i] = 1;
// con[c].add(i);
// //System.out.print(i + " ");
// for(int j = 0;j<arr[i].size();j++){
// dfs(arr[i].get(j));
// }
//
// }
//
//
// public static void dfss(int i){
// if(visited[i] == 1){
// return;
// }
//
// visited[i] = 1;
//
// for(int j = 0;j<arr[i].size();j++){
// dfss(arr[i].get(j));
// }
// // System.out.println(i);
// stack.push(i);
// }
//
// public static void reverse(){
// ArrayList[] temp = new ArrayList[n];
//
// for(int i = 0;i<n;i++){
// temp[i] = new ArrayList();
// }
//
// for(int i = 0;i<n;i++){
// for(int j = 0;j<arr[i].size();j++){
// temp[arr[i].get(j)].add(i);
// }
// }
//
// arr = temp;
//
// }
//
//
public static boolean isPrime(int n) {
// Corner cases
if (n <= 1)
return false;
if (n <= 3)
return true;
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
// union code starts
// union code ends
// // Segment tree code begins
//
//
// static void build(int node,int start,int end)
// {
// if(start==end)
// tree[node]=a[start];
// else
// {
// int mid=(start+end)/2;
// build(2*node,start,mid);
// build(2*node+1,mid+1,end);
// if(tree[2*node]<tree[2*node+1])
// tree[node]=tree[2*node];
// else
// tree[node]=tree[2*node+1];
// }
// }
//
//
// static void update(int node,int start,int end,int idx,int val)
// {
// if(start==end)
// {
// a[idx]=val;
// tree[node]=val;
// }
// else
// {
// int mid=(start+end)/2;
// if(idx>=start&&idx<=mid)
// update(2*node,start,mid,idx,val);
// else
// update(2*node+1,mid+1,end,idx,val);
// if(tree[2*node]<tree[2*node+1])
// tree[node]=tree[2*node];
// else
// tree[node]=tree[2*node+1];
// }
// }
//
// static int query(int node,int start,int end,int l,int r)
// {
// if(l>end||start>r)
// return 100005;
// if(l<=start&&r>=end)
// return tree[node];
// int p1,p2;
// int mid=(start+end)/2;
// p1=query(2*node,start,mid,l,r);
// p2=query(2*node+1,mid+1,end,l,r);
// if(p1<p2)
// return p1;
// else
// return p2;
// }
//
//
//
//}
}
class Stone implements Comparable<Stone>{
int a;
int b;
int c;
int i;
Stone(int a,int b,int c,int d){
this.a = a;
this.b = b;
this.c = c;
this.i = d;
}
@Override
public int compareTo(Stone b) {
if(this.c > b.c){
return 1;
}else if(this.c < b.c){
return -1;
}else if(this.b > b.b){
return 1;
}else if(this.b < b.b){
return -1;
}else if(this.a > b.a){
return 1;
}else if(this.a < b.a){
return -1;
}
return 0;
}
}
class Node{
int a;
int b;
}
class point{
int a;
int b;
}
class MyComp2 implements Comparator<Node>{
@Override
public int compare(Node o1, Node o2) {
if( o1.b > o2.b){
return 1;
}else if( o1.b < o2.b){
return -1;
}else{
if(o1.a == o2.a){
return 0;
}else if(o1.a > o2.a){
return 1;
}else if(o1.a < o2.a){
return -1;
}
}
return 0;
}
}
class Card implements Comparable<Card>
{
int a,b;
public Card(int w,int h)
{
this.a=w;
this.b=h;
}
public int compareTo(Card that)
{
return this.a-that.a;
}
}
|
JATC's math teacher always gives the class some interesting math problems so that they don't get bored. Today the problem is as follows. Given an integer n, you can perform the following operations zero or more times:
* mul x: multiplies n by x (where x is an arbitrary positive integer).
* sqrt: replaces n with √{n} (to apply this operation, √{n} must be an integer).
You can perform these operations as many times as you like. What is the minimum value of n, that can be achieved and what is the minimum number of operations, to achieve that minimum value?
Apparently, no one in the class knows the answer to this problem, maybe you can help them?
Input
The only line of the input contains a single integer n (1 ≤ n ≤ 10^6) — the initial number.
Output
Print two integers: the minimum integer n that can be achieved using the described operations and the minimum number of operations required.
Examples
Input
20
Output
10 2
Input
5184
Output
6 4
Note
In the first example, you can apply the operation mul 5 to get 100 and then sqrt to get 10.
In the second example, you can first apply sqrt to get 72, then mul 18 to get 1296 and finally two more sqrt and you get 6.
Note, that even if the initial value of n is less or equal 10^6, it can still become greater than 10^6 after applying one or more operations.
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
const int mod = 1e9 + 7;
int dcmp(long double x, long double y) {
return fabs(x - y) <= 1e-12 ? 0 : x < y ? -1 : 1;
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int n;
map<int, int> mp;
void pf() {
for (int i = 2; 1ll * i * i <= n; i++) {
while (n % i == 0) {
mp[i]++;
n /= i;
}
}
if (n > 1) mp[n]++;
}
int main() {
fast();
cin >> n;
pf();
int cnt = 0, mx = 0;
int num = 1;
for (auto e : mp) {
mx = max(e.second, mx);
num *= e.first;
}
int lo = 0, hi = 30, ans = 1;
while (lo <= hi) {
int md = (lo + (hi - lo) / 2);
if ((1 << md) >= mx) {
hi = md - 1;
ans = md;
} else
lo = md + 1;
}
for (auto e : mp) {
if (e.second < (1 << ans)) {
cnt++;
break;
}
}
cout << num << " ";
cout << cnt + ans << '\n';
return 0;
}
|
The Fair Nut lives in n story house. a_i people live on the i-th floor of the house. Every person uses elevator twice a day: to get from the floor where he/she lives to the ground (first) floor and to get from the first floor to the floor where he/she lives, when he/she comes back home in the evening.
It was decided that elevator, when it is not used, will stay on the x-th floor, but x hasn't been chosen yet. When a person needs to get from floor a to floor b, elevator follows the simple algorithm:
* Moves from the x-th floor (initially it stays on the x-th floor) to the a-th and takes the passenger.
* Moves from the a-th floor to the b-th floor and lets out the passenger (if a equals b, elevator just opens and closes the doors, but still comes to the floor from the x-th floor).
* Moves from the b-th floor back to the x-th.
The elevator never transposes more than one person and always goes back to the floor x before transposing a next passenger. The elevator spends one unit of electricity to move between neighboring floors. So moving from the a-th floor to the b-th floor requires |a - b| units of electricity.
Your task is to help Nut to find the minimum number of electricity units, that it would be enough for one day, by choosing an optimal the x-th floor. Don't forget than elevator initially stays on the x-th floor.
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the number of floors.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100) — the number of people on each floor.
Output
In a single line, print the answer to the problem — the minimum number of electricity units.
Examples
Input
3
0 2 1
Output
16
Input
2
1 1
Output
4
Note
In the first example, the answer can be achieved by choosing the second floor as the x-th floor. Each person from the second floor (there are two of them) would spend 4 units of electricity per day (2 to get down and 2 to get up), and one person from the third would spend 8 units of electricity per day (4 to get down and 4 to get up). 4 ⋅ 2 + 8 ⋅ 1 = 16.
In the second example, the answer can be achieved by choosing the first floor as the x-th floor.
|
n = int(input())
arr = list(map(int, input().split()))
cur = 0
ans = 100000000
for x in range(n):
cur = 0
for i in range(n):
summ = 0
summ += abs(x - i)
summ += i
summ += x
summ += x
summ += i
summ += abs(x - i)
summ *= arr[i]
cur += summ
if cur < ans:
ans = cur
print(ans)
|
Today is tuesday, that means there is a dispute in JOHNNY SOLVING team again: they try to understand who is Johnny and who is Solving. That's why guys asked Umnik to help them. Umnik gave guys a connected graph with n vertices without loops and multiedges, such that a degree of any vertex is at least 3, and also he gave a number 1 ≤ k ≤ n. Because Johnny is not too smart, he promised to find a simple path with length at least n/k in the graph. In reply, Solving promised to find k simple by vertices cycles with representatives, such that:
* Length of each cycle is at least 3.
* Length of each cycle is not divisible by 3.
* In each cycle must be a representative - vertex, which belongs only to this cycle among all printed cycles.
You need to help guys resolve the dispute, for that you need to find a solution for Johnny: a simple path with length at least n/k (n is not necessarily divided by k), or solution for Solving: k cycles that satisfy all the conditions above. If there is no any solution - print -1.
Input
The first line contains three integers n, m and k (1 ≤ k ≤ n ≤ 2.5 ⋅ 10^5, 1 ≤ m ≤ 5 ⋅ 10^5)
Next m lines describe edges of the graph in format v, u (1 ≤ v, u ≤ n). It's guaranteed that v ≠ u and all m pairs are distinct.
It's guaranteed that a degree of each vertex is at least 3.
Output
Print PATH in the first line, if you solve problem for Johnny. In the second line print the number of vertices in the path c (c ≥ n/k). And in the third line print vertices describing the path in route order.
Print CYCLES in the first line, if you solve problem for Solving. In the following lines describe exactly k cycles in the following format: in the first line print the size of the cycle c (c ≥ 3). In the second line print the cycle in route order. Also, the first vertex in the cycle must be a representative.
Print -1 if there is no any solution. The total amount of printed numbers in the output must be at most 10^6. It's guaranteed, that if exists any solution then there is a correct output satisfies this restriction.
Examples
Input
4 6 2
1 2
1 3
1 4
2 3
2 4
3 4
Output
PATH
4
1 2 3 4
Input
10 18 2
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
1 10
2 3
3 4
2 4
5 6
6 7
5 7
8 9
9 10
8 10
Output
CYCLES
4
4 1 2 3
4
7 1 5 6
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5 * 100005;
vector<int> a[maxn];
int n, m, k, lim;
int head[maxn], Next[maxn * 2], to[maxn * 2], tot = 0;
int d[maxn], fa[maxn], size[maxn];
bool vis[maxn];
void add(int x, int y) {
to[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
}
void dfs_tree(int x, int f) {
size[x] = 1;
for (int i = head[x]; i; i = Next[i]) {
int y = to[i];
if (y == f || vis[y]) continue;
d[y] = d[x] + 1;
fa[y] = x;
vis[y] = 1;
dfs_tree(y, x);
size[x] += size[y];
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
lim = ceil((double)n * 1.0 / k);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
vis[1] = 1;
d[1] = 1;
dfs_tree(1, 0);
int pos = 0;
for (int i = 1; i <= n; i++) {
if (d[i] >= lim) {
puts("PATH");
pos = i;
printf("%d\n", d[i]);
while (pos) {
printf("%d ", pos);
pos = fa[pos];
}
printf("\n");
return 0;
}
}
int cnt = 0;
puts("CYCLES");
for (int i = 1; i <= n; i++) {
if (size[i] == 1) {
int p1 = 0, p2 = 0;
for (int j = head[i]; j; j = Next[j]) {
int y = to[j];
if (y == fa[i]) continue;
if (!p1)
p1 = y;
else {
if (!p2) {
p2 = y;
break;
}
}
}
if (d[p1] < d[p2]) swap(p1, p2);
int c1 = d[i] - d[p1] + 1, c2 = d[i] - d[p2] + 1, c3 = d[p1] - d[p2] + 2;
if (c1 > 3 && c1 % 3 != 0) {
cnt++;
pos = i;
while (pos != fa[p1]) {
a[cnt].push_back(pos);
pos = fa[pos];
}
} else if (c2 > 3 && c2 % 3 != 0) {
cnt++;
pos = i;
while (pos != fa[p2]) {
a[cnt].push_back(pos);
pos = fa[pos];
}
} else if (c3 > 3 && c3 % 3 != 0) {
cnt++;
pos = p1;
while (pos != fa[p2]) {
a[cnt].push_back(pos);
pos = fa[pos];
}
a[cnt].push_back(i);
}
}
if (cnt == k) break;
}
for (int i = 1; i <= cnt; i++) {
printf("%d\n", a[i].size());
for (int j = 0; j < a[i].size(); j++) printf("%d ", a[i][j]);
printf("\n");
}
return 0;
}
|
Cowboy Vlad has a birthday today! There are n children who came to the celebration. In order to greet Vlad, the children decided to form a circle around him. Among the children who came, there are both tall and low, so if they stand in a circle arbitrarily, it may turn out, that there is a tall and low child standing next to each other, and it will be difficult for them to hold hands. Therefore, children want to stand in a circle so that the maximum difference between the growth of two neighboring children would be minimal possible.
Formally, let's number children from 1 to n in a circle order, that is, for every i child with number i will stand next to the child with number i+1, also the child with number 1 stands next to the child with number n. Then we will call the discomfort of the circle the maximum absolute difference of heights of the children, who stand next to each other.
Please help children to find out how they should reorder themselves, so that the resulting discomfort is smallest possible.
Input
The first line contains a single integer n (2 ≤ n ≤ 100) — the number of the children who came to the cowboy Vlad's birthday.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) denoting heights of every child.
Output
Print exactly n integers — heights of the children in the order in which they should stand in a circle. You can start printing a circle with any child.
If there are multiple possible answers, print any of them.
Examples
Input
5
2 1 1 3 2
Output
1 2 3 2 1
Input
3
30 10 20
Output
10 20 30
Note
In the first example, the discomfort of the circle is equal to 1, since the corresponding absolute differences are 1, 1, 1 and 0. Note, that sequences [2, 3, 2, 1, 1] and [3, 2, 1, 1, 2] form the same circles and differ only by the selection of the starting point.
In the second example, the discomfort of the circle is equal to 20, since the absolute difference of 10 and 30 is equal to 20.
|
n = int(input())
arr = [int(i) for i in input().split()]
arr1, arr2 = [], []
arr.sort(reverse = True)
for i in range(n):
if i%2==0:
arr1.append(arr[i])
else:
arr2.append(arr[i])
arr2.reverse()
for i in arr2:
arr1.append(i)
print(*arr1)
|
The Kingdom of Kremland is a tree (a connected undirected graph without cycles) consisting of n vertices. Each vertex i has its own value a_i. All vertices are connected in series by edges. Formally, for every 1 ≤ i < n there is an edge between the vertices of i and i+1.
Denote the function f(l, r), which takes two integers l and r (l ≤ r):
* We leave in the tree only vertices whose values range from l to r.
* The value of the function will be the number of connected components in the new graph.
Your task is to calculate the following sum: $$$∑_{l=1}^{n} ∑_{r=l}^{n} f(l, r) $$$
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of vertices in the tree.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n) — the values of the vertices.
Output
Print one number — the answer to the problem.
Examples
Input
3
2 1 3
Output
7
Input
4
2 1 1 3
Output
11
Input
10
1 5 2 5 5 3 10 6 5 1
Output
104
Note
In the first example, the function values will be as follows:
* f(1, 1)=1 (there is only a vertex with the number 2, which forms one component)
* f(1, 2)=1 (there are vertices 1 and 2 that form one component)
* f(1, 3)=1 (all vertices remain, one component is obtained)
* f(2, 2)=1 (only vertex number 1)
* f(2, 3)=2 (there are vertices 1 and 3 that form two components)
* f(3, 3)=1 (only vertex 3)
Totally out 7.
In the second example, the function values will be as follows:
* f(1, 1)=1
* f(1, 2)=1
* f(1, 3)=1
* f(1, 4)=1
* f(2, 2)=1
* f(2, 3)=2
* f(2, 4)=2
* f(3, 3)=1
* f(3, 4)=1
* f(4, 4)=0 (there is no vertex left, so the number of components is 0)
Totally out 11.
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int str[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> str[i];
long long ans = 0;
for (int i = 0; i < n; i++) {
if (i == 0) {
ans += 1ll * str[i] * (n - str[i] + 1);
} else {
if (str[i] > str[i - 1])
ans += 1ll * (str[i] - str[i - 1]) * (n - str[i] + 1);
else
ans += 1ll * (str[i - 1] - str[i]) * str[i];
}
}
cout << ans << endl;
return 0;
}
|
Nauuo is a girl who loves drawing circles.
One day she has drawn a circle and wanted to draw a tree on it.
The tree is a connected undirected graph consisting of n nodes and n-1 edges. The nodes are numbered from 1 to n.
Nauuo wants to draw a tree on the circle, the nodes of the tree should be in n distinct points on the circle, and the edges should be straight without crossing each other.
"Without crossing each other" means that every two edges have no common point or the only common point is an endpoint of both edges.
Nauuo wants to draw the tree using a permutation of n elements. A permutation of n elements is a sequence of integers p_1,p_2,…,p_n in which every integer from 1 to n appears exactly once.
After a permutation is chosen Nauuo draws the i-th node in the p_i-th point on the circle, then draws the edges connecting the nodes.
The tree is given, Nauuo wants to know how many permutations are there so that the tree drawn satisfies the rule (the edges are straight without crossing each other). She only wants to know the answer modulo 998244353, can you help her?
It is obvious that whether a permutation is valid or not does not depend on which n points on the circle are chosen.
Input
The first line contains a single integer n (2≤ n≤ 2⋅ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines contains two integers u and v (1≤ u,v≤ n), denoting there is an edge between u and v.
It is guaranteed that the given edges form a tree.
Output
The output contains a single integer — the number of permutations suitable to draw the given tree on a circle satisfying the rule, modulo 998244353.
Examples
Input
4
1 2
1 3
2 4
Output
16
Input
4
1 2
1 3
1 4
Output
24
Note
Example 1
All valid permutations and their spanning trees are as follows.
<image>
Here is an example of invalid permutation: the edges (1,3) and (2,4) are crossed.
<image>
Example 2
Every permutation leads to a valid tree, so the answer is 4! = 24.
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-8;
const int MOD = 998244353;
const int dy[] = {1, 0, -1, 0}, dx[] = {0, -1, 0, 1};
vector<int> edge[200000];
long long fact[200001];
void init() {
fact[0] = fact[1] = 1;
for (int i = (2); i < (200001); ++i) fact[i] = (fact[i - 1] * i) % MOD;
}
long long ans = 1;
void dfs(int par, int ver) {
(ans *= fact[edge[ver].size()]) %= MOD;
for (int e : edge[ver])
if (e != par) {
dfs(ver, e);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
init();
int n;
cin >> n;
for (int i = (0); i < (n - 1); ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
edge[u].emplace_back(v);
edge[v].emplace_back(u);
}
dfs(-1, 0);
(ans *= n) %= MOD;
cout << ans << '\n';
return 0;
}
|
Tokitsukaze is one of the characters in the game "Kantai Collection". In this game, every character has a common attribute — health points, shortened to HP.
In general, different values of HP are grouped into 4 categories:
* Category A if HP is in the form of (4 n + 1), that is, when divided by 4, the remainder is 1;
* Category B if HP is in the form of (4 n + 3), that is, when divided by 4, the remainder is 3;
* Category C if HP is in the form of (4 n + 2), that is, when divided by 4, the remainder is 2;
* Category D if HP is in the form of 4 n, that is, when divided by 4, the remainder is 0.
The above-mentioned n can be any integer.
These 4 categories ordered from highest to lowest as A > B > C > D, which means category A is the highest and category D is the lowest.
While playing the game, players can increase the HP of the character. Now, Tokitsukaze wants you to increase her HP by at most 2 (that is, either by 0, 1 or 2). How much should she increase her HP so that it has the highest possible category?
Input
The only line contains a single integer x (30 ≤ x ≤ 100) — the value Tokitsukaze's HP currently.
Output
Print an integer a (0 ≤ a ≤ 2) and an uppercase letter b (b ∈ { A, B, C, D }), representing that the best way is to increase her HP by a, and then the category becomes b.
Note that the output characters are case-sensitive.
Examples
Input
33
Output
0 A
Input
98
Output
1 B
Note
For the first example, the category of Tokitsukaze's HP is already A, so you don't need to enhance her ability.
For the second example:
* If you don't increase her HP, its value is still 98, which equals to (4 × 24 + 2), and its category is C.
* If you increase her HP by 1, its value becomes 99, which equals to (4 × 24 + 3), and its category becomes B.
* If you increase her HP by 2, its value becomes 100, which equals to (4 × 25), and its category becomes D.
Therefore, the best way is to increase her HP by 1 so that the category of her HP becomes B.
|
n=int(input())
d={}
d[0]='1 A'
d[1]='0 A'
d[2]='1 B'
d[3]='2 A'
x=n%4
print(d[x])
|
A sky scraper with 1000 floors has been built in the city of N. It has modern superfast elevators to help to travel from one floor to another. Each elevator has two doors, the front one and the back one. If one goes in through the front door, he goes out through the back one and vice versa. The elevator has two rails numbered with numbers 1 and 2. Rail 1 is located to the left of the entrance to the front door (or correspondingly, to the right of the entrance to the back door). Rail 2 is located opposite it, to the right of the entrance to the front door and to the left of the entrance to the back door. We know that each person in the city of N holds at a rail with the strongest hand.
One day a VIP person visited the city and of course, he took a look at the skyscraper and took a ride in the elevator. We know the door through which he entered and the rail he was holding at. Now we need to determine as soon as possible whether he is left-handed or right-handed.
Input
The first line indicates the door through which the very important person entered the elevator. It contains "front" if the person enters the elevator through the front door and "back" if he entered the elevator through the back door. The second line contains integer a (1 ≤ a ≤ 2) which denotes the number of the rail at which the person was holding.
Output
Print character "R" if the VIP is right-handed or "L" if he is left-handed.
Examples
Input
front
1
Output
L
|
import java.io.*;
import java.util.*;
import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
public class Main{
public static void main(String[]args){
InputStream in = System.in;
PrintWriter out = new PrintWriter(System.out);
try{
in = new BufferedInputStream(new FileInputStream(new File("input.txt")));
out = new PrintWriter(new BufferedOutputStream(new FileOutputStream("output.txt")));
}catch (Exception e) {
}
new Main().run(in,out);
out.flush();
}
private void debug(Object...os){
System.err.println(deepToString(os));
}
private void run(InputStream in,PrintWriter out){
String s = next(in);
int t = nextInt(in)-1;
// t=0;
int a = s.equals("front") ? 0:1;
out.println((t^a)==0 ? "L":"R");
}
private String next(InputStream in) {
try {
StringBuilder res = new StringBuilder("");
int c = in.read();
while (Character.isWhitespace(c))
c = in.read();
do {
res.append((char) c);
} while (!Character.isWhitespace(c = in.read()));
return res.toString();
} catch (Exception e) {
return null;
}
}
private int nextInt(InputStream in){
try{
int c=in.read();
if(c==-1) return c;
while(c!='-'&&(c<'0'||'9'<c)){
c=in.read();
if(c==-1) return c;
}
if(c=='-') return -nextInt(in);
int res=0;
do{
res*=10;
res+=c-'0';
c=in.read();
}while('0'<=c&&c<='9');
return res;
}catch(Exception e){
return -1;
}
}
}
|
Petya loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.
Petya has a number consisting of n digits without leading zeroes. He represented it as an array of digits without leading zeroes. Let's call it d. The numeration starts with 1, starting from the most significant digit. Petya wants to perform the following operation k times: find the minimum x (1 ≤ x < n) such that dx = 4 and dx + 1 = 7, if x is odd, then to assign dx = dx + 1 = 4, otherwise to assign dx = dx + 1 = 7. Note that if no x was found, then the operation counts as completed and the array doesn't change at all.
You are given the initial number as an array of digits and the number k. Help Petya find the result of completing k operations.
Input
The first line contains two integers n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ 109) — the number of digits in the number and the number of completed operations. The second line contains n digits without spaces representing the array of digits d, starting with d1. It is guaranteed that the first digit of the number does not equal zero.
Output
In the single line print the result without spaces — the number after the k operations are fulfilled.
Examples
Input
7 4
4727447
Output
4427477
Input
4 2
4478
Output
4478
Note
In the first sample the number changes in the following sequence: 4727447 → 4427447 → 4427477 → 4427447 → 4427477.
In the second sample: 4478 → 4778 → 4478.
|
#include <bits/stdc++.h>
char A[100001];
int op;
int cnt;
int n;
int at;
inline void solve() {
while (cnt < op) {
if (at == n - 1) {
break;
} else {
if (A[at] == '4' && A[at + 1] == '7') {
if (at % 2 == 0) {
if (at == n - 2) {
A[at + 1] = '4';
cnt++;
at++;
} else if (A[at + 2] != 7) {
A[at + 1] = '4';
cnt++;
at++;
} else {
if ((op - cnt) % 2 == 1) {
A[at + 1] = '4';
}
cnt = op + 1;
}
} else {
if (at > 0) {
if (A[at - 1] == '4') {
if ((op - cnt) % 2 == 1) {
A[at] = '7';
}
cnt = op + 1;
} else {
cnt++;
A[at] = '7';
at++;
}
}
}
} else {
at++;
}
}
}
}
int main() {
scanf("%d%d", &n, &op);
scanf("%s", A);
if (n > 1) {
at = 0;
solve();
}
printf("%s\n", A);
return 0;
}
|
You are given a huge integer a consisting of n digits (n is between 1 and 3 ⋅ 10^5, inclusive). It may contain leading zeros.
You can swap two digits on adjacent (neighboring) positions if the swapping digits are of different parity (that is, they have different remainders when divided by 2).
For example, if a = 032867235 you can get the following integers in a single operation:
* 302867235 if you swap the first and the second digits;
* 023867235 if you swap the second and the third digits;
* 032876235 if you swap the fifth and the sixth digits;
* 032862735 if you swap the sixth and the seventh digits;
* 032867325 if you swap the seventh and the eighth digits.
Note, that you can't swap digits on positions 2 and 4 because the positions are not adjacent. Also, you can't swap digits on positions 3 and 4 because the digits have the same parity.
You can perform any number (possibly, zero) of such operations.
Find the minimum integer you can obtain.
Note that the resulting integer also may contain leading zeros.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input.
The only line of each test case contains the integer a, its length n is between 1 and 3 ⋅ 10^5, inclusive.
It is guaranteed that the sum of all values n does not exceed 3 ⋅ 10^5.
Output
For each test case print line — the minimum integer you can obtain.
Example
Input
3
0709
1337
246432
Output
0079
1337
234642
Note
In the first test case, you can perform the following sequence of operations (the pair of swapped digits is highlighted): 0 \underline{70} 9 → 0079.
In the second test case, the initial integer is optimal.
In the third test case you can perform the following sequence of operations: 246 \underline{43} 2 → 24 \underline{63}42 → 2 \underline{43} 642 → 234642.
|
# -*- coding: utf-8 -*-
"""
Created on Fri Nov 1 14:39:37 2019
@author: uditg
"""
ans={}
test=int(input())
for each in range(test):
num=input()
n=len(num)
num={i:int(num[i]) for i in range(n)}
output={}
even={}
odd={}
even_count=0
odd_count=0
for i in range(n):
if num[i]%2==0:
even[even_count]=num[i]
even_count+=1
else:
odd[odd_count]=num[i]
odd_count+=1
num={}
#print("even",even,"and",odd,"\n")
i=0
j=0
count=0
while even and odd:
output[count]=(min(even[i],odd[j]))
if min(even[i],odd[j])==even[i]:
del even[i]
i+=1
else:
del odd[j]
j+=1
count+=1
if even:
for every in range(i,max(even.keys())+1):
output[count]=even[every]
count+=1
#output+=[even[every] for every in range(i,max(even.keys())+1)]
if odd:
for every in range(j,max(odd.keys())+1):
output[count]=odd[every]
#print(output[count])
count+=1
#output+=[odd[every] for every in range(j,max(odd.keys())+1)]
outputs=[str(output[me]) for me in range(max(output.keys())+1)]
ans[each]="".join(outputs)
for each in range(test):
print(ans[each])
|
A new delivery of clothing has arrived today to the clothing store. This delivery consists of a ties, b scarves, c vests and d jackets.
The store does not sell single clothing items — instead, it sells suits of two types:
* a suit of the first type consists of one tie and one jacket;
* a suit of the second type consists of one scarf, one vest and one jacket.
Each suit of the first type costs e coins, and each suit of the second type costs f coins.
Calculate the maximum possible cost of a set of suits that can be composed from the delivered clothing items. Note that one item cannot be used in more than one suit (though some items may be left unused).
Input
The first line contains one integer a (1 ≤ a ≤ 100 000) — the number of ties.
The second line contains one integer b (1 ≤ b ≤ 100 000) — the number of scarves.
The third line contains one integer c (1 ≤ c ≤ 100 000) — the number of vests.
The fourth line contains one integer d (1 ≤ d ≤ 100 000) — the number of jackets.
The fifth line contains one integer e (1 ≤ e ≤ 1 000) — the cost of one suit of the first type.
The sixth line contains one integer f (1 ≤ f ≤ 1 000) — the cost of one suit of the second type.
Output
Print one integer — the maximum total cost of some set of suits that can be composed from the delivered items.
Examples
Input
4
5
6
3
1
2
Output
6
Input
12
11
13
20
4
6
Output
102
Input
17
14
5
21
15
17
Output
325
Note
It is possible to compose three suits of the second type in the first example, and their total cost will be 6. Since all jackets will be used, it's impossible to add anything to this set.
The best course of action in the second example is to compose nine suits of the first type and eleven suits of the second type. The total cost is 9 ⋅ 4 + 11 ⋅ 6 = 102.
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
int a, b, c, d, e, f;
int main() {
scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &e, &f);
int tmp1 = min(a, d);
int tmp2 = min(b, min(c, d));
int ans = 0;
if (e > f) {
ans += tmp1 * e;
tmp2 = min(tmp2, d - tmp1);
ans += tmp2 * f;
} else {
ans += tmp2 * f;
tmp1 = min(tmp1, d - tmp2);
ans += tmp1 * e;
}
printf("%d", ans);
}
|
There is a robot in a warehouse and n packages he wants to collect. The warehouse can be represented as a coordinate grid. Initially, the robot stays at the point (0, 0). The i-th package is at the point (x_i, y_i). It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The robot is semi-broken and only can move up ('U') and right ('R'). In other words, in one move the robot can go from the point (x, y) to the point (x + 1, y) or to the point (x, y + 1).
As we say above, the robot wants to collect all n packages (in arbitrary order). He wants to do it with the minimum possible number of moves. If there are several possible traversals, the robot wants to choose the lexicographically smallest path.
The string s of length n is lexicographically less than the string t of length n if there is some index 1 ≤ j ≤ n that for all i from 1 to j-1 s_i = t_i and s_j < t_j. It is the standard comparison of string, like in a dictionary. Most programming languages compare strings in this way.
Input
The first line of the input contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Then test cases follow.
The first line of a test case contains one integer n (1 ≤ n ≤ 1000) — the number of packages.
The next n lines contain descriptions of packages. The i-th package is given as two integers x_i and y_i (0 ≤ x_i, y_i ≤ 1000) — the x-coordinate of the package and the y-coordinate of the package.
It is guaranteed that there are no two packages at the same point. It is also guaranteed that the point (0, 0) doesn't contain a package.
The sum of all values n over test cases in the test doesn't exceed 1000.
Output
Print the answer for each test case.
If it is impossible to collect all n packages in some order starting from (0,0), print "NO" on the first line.
Otherwise, print "YES" in the first line. Then print the shortest path — a string consisting of characters 'R' and 'U'. Among all such paths choose the lexicographically smallest path.
Note that in this problem "YES" and "NO" can be only uppercase words, i.e. "Yes", "no" and "YeS" are not acceptable.
Example
Input
3
5
1 3
1 2
3 3
5 5
4 3
2
1 0
0 1
1
4 3
Output
YES
RUUURRRRUU
NO
YES
RRRRUUU
Note
For the first test case in the example the optimal path RUUURRRRUU is shown below:
<image>
|
t=int(input())
for q in range(t):
n=int(input())
a=[list(map(int,input().split())) for i in range(n)]
a.sort()
ans=""
x,y=0,0
f=0
for i in range(n):
if a[i][0]>=x and a[i][1]>=y:
ans+='R'*(a[i][0]-x)
x=a[i][0]
ans+='U'*(a[i][1]-y)
y=a[i][1]
else:
f=1
print('NO')
break
if f==0:
print('YES')
print(ans)
|
After a long party Petya decided to return home, but he turned out to be at the opposite end of the town from his home. There are n crossroads in the line in the town, and there is either the bus or the tram station at each crossroad.
The crossroads are represented as a string s of length n, where s_i = A, if there is a bus station at i-th crossroad, and s_i = B, if there is a tram station at i-th crossroad. Currently Petya is at the first crossroad (which corresponds to s_1) and his goal is to get to the last crossroad (which corresponds to s_n).
If for two crossroads i and j for all crossroads i, i+1, …, j-1 there is a bus station, one can pay a roubles for the bus ticket, and go from i-th crossroad to the j-th crossroad by the bus (it is not necessary to have a bus station at the j-th crossroad). Formally, paying a roubles Petya can go from i to j if s_t = A for all i ≤ t < j.
If for two crossroads i and j for all crossroads i, i+1, …, j-1 there is a tram station, one can pay b roubles for the tram ticket, and go from i-th crossroad to the j-th crossroad by the tram (it is not necessary to have a tram station at the j-th crossroad). Formally, paying b roubles Petya can go from i to j if s_t = B for all i ≤ t < j.
For example, if s="AABBBAB", a=4 and b=3 then Petya needs:
<image>
* buy one bus ticket to get from 1 to 3,
* buy one tram ticket to get from 3 to 6,
* buy one bus ticket to get from 6 to 7.
Thus, in total he needs to spend 4+3+4=11 roubles. Please note that the type of the stop at the last crossroad (i.e. the character s_n) does not affect the final expense.
Now Petya is at the first crossroad, and he wants to get to the n-th crossroad. After the party he has left with p roubles. He's decided to go to some station on foot, and then go to home using only public transport.
Help him to choose the closest crossroad i to go on foot the first, so he has enough money to get from the i-th crossroad to the n-th, using only tram and bus tickets.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
The first line of each test case consists of three integers a, b, p (1 ≤ a, b, p ≤ 10^5) — the cost of bus ticket, the cost of tram ticket and the amount of money Petya has.
The second line of each test case consists of one string s, where s_i = A, if there is a bus station at i-th crossroad, and s_i = B, if there is a tram station at i-th crossroad (2 ≤ |s| ≤ 10^5).
It is guaranteed, that the sum of the length of strings s by all test cases in one test doesn't exceed 10^5.
Output
For each test case print one number — the minimal index i of a crossroad Petya should go on foot. The rest of the path (i.e. from i to n he should use public transport).
Example
Input
5
2 2 1
BB
1 1 1
AB
3 2 8
AABBBBAABB
5 3 4
BBBBB
2 1 1
ABABAB
Output
2
1
3
1
6
|
import java.util.*;
public class Solution{
public static void main(String args[]){
Scanner in=new Scanner (System.in);
int t=in.nextInt();
T:while(--t>=0){
int a=in.nextInt();
int b=in.nextInt();
int p=in.nextInt();
String s=in.next();
int c=0;
for(int i=s.length()-2;i>=0;){
char ch=s.charAt(i);
c+=ch=='A' ? a:b;
if(c>p){
System.out.println(i+2);
continue T;
}
while(i>=0 && s.charAt(i)==ch){
i--;
}
}
System.out.println(1);
}
}
}
|
This is the easy version of the problem. The only difference between easy and hard versions is the constraint of m. You can make hacks only if both versions are solved.
Chiori loves dolls and now she is going to decorate her bedroom!
<image>
As a doll collector, Chiori has got n dolls. The i-th doll has a non-negative integer value a_i (a_i < 2^m, m is given). Chiori wants to pick some (maybe zero) dolls for the decoration, so there are 2^n different picking ways.
Let x be the bitwise-xor-sum of values of dolls Chiori picks (in case Chiori picks no dolls x = 0). The value of this picking way is equal to the number of 1-bits in the binary representation of x. More formally, it is also equal to the number of indices 0 ≤ i < m, such that \left⌊ (x)/(2^i) \right⌋ is odd.
Tell her the number of picking ways with value i for each integer i from 0 to m. Due to the answers can be very huge, print them by modulo 998 244 353.
Input
The first line contains two integers n and m (1 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ m ≤ 35) — the number of dolls and the maximum value of the picking way.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i < 2^m) — the values of dolls.
Output
Print m+1 integers p_0, p_1, …, p_m — p_i is equal to the number of picking ways with value i by modulo 998 244 353.
Examples
Input
4 4
3 5 8 14
Output
2 2 6 6 0
Input
6 7
11 45 14 9 19 81
Output
1 2 11 20 15 10 5 0
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
template <typename T>
void maxtt(T &t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T &t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
string direc = "RDLU";
const long long MOD2 = (long long)998244353 * (long long)998244353;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 998244353) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
long long a[200135];
struct lsp {
long long a[60] = {0};
const int maxBit = 54;
bool insert(long long x) {
for (int i = maxBit; ~i; i--)
if (x & (1LL << i)) {
if (a[i] != 0)
x ^= a[i];
else {
for (int(j) = 0; (j) < (int)(i); (j)++)
if (x & (1LL << j)) x ^= a[j];
for (int j = i + 1; j <= maxBit; j++)
if (a[j] & (1LL << i)) a[j] ^= x;
a[i] = x;
return 1;
}
}
return 0;
}
lsp getOrthogonal(int m) {
lsp res;
vector<int> vp;
for (int j = m - 1; j >= 0; j--)
if (!a[j]) {
vp.push_back(j);
res.a[j] |= 1LL << j;
}
for (int j = m - 1; j >= 0; j--)
if (a[j]) {
int cc = 0;
for (int z = m - 1; z >= 0; z--)
if (!a[z]) {
long long w = (a[j] >> z) & 1;
res.a[vp[cc]] |= w << j;
cc++;
}
}
return res;
}
} sp;
int p[66], q[66];
void ppt() {
for (int i = 0; i <= m; i++) {
printf("%lld ", (long long)p[i] * fastPow(2, n - k) % 998244353);
}
exit(0);
}
vector<long long> bs;
inline void dfs(int *p, int k, int i, long long x) {
if (i == k) {
p[__builtin_popcountll(x)]++;
return;
}
dfs(p, k, i + 1, x);
dfs(p, k, i + 1, x ^ bs[i]);
}
void calsm(lsp sp, int *p, int k) {
bs.clear();
for (int(j) = 0; (j) < (int)(sp.maxBit); (j)++)
if (sp.a[j]) bs.push_back(sp.a[j]);
assert(bs.size() == k);
dfs(p, k, 0, 0);
}
void calbg() {
vector<vector<int>> C(60, vector<int>(60, 0));
C[0][0] = 1;
for (int i = 1; i <= 55; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 998244353;
}
}
vector<vector<int>> w(m + 1, vector<int>(m + 1, 0));
for (int c = 0; c <= m; c++) {
for (int d = 0; d <= m; d++) {
for (int j = 0; j <= c; j++) {
int val = (long long)C[d][j] * C[m - d][c - j] % 998244353;
if (j % 2 == 0)
addmod(w[c][d], val);
else
addmod(w[c][d], 998244353 - val);
}
}
}
lsp B = sp.getOrthogonal(m);
calsm(B, q, m - k);
for (int(c) = 0; (c) < (int)(m + 1); (c)++) {
for (int d = 0; d <= m; d++) {
addmod(p[c], (long long)q[d] * w[c][d] % 998244353);
}
}
int tmp = fastPow(2, m - k);
tmp = fastPow(tmp, 998244353 - 2);
for (int(c) = 0; (c) < (int)(m + 1); (c)++)
p[c] = (long long)p[c] * tmp % 998244353;
ppt();
}
void fmain(int tid) {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%lld", a + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) k += sp.insert(a[i]);
if (k <= m / 2) {
calsm(sp, p, k);
ppt();
}
calbg();
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
You might have remembered Theatre square from the [problem 1A](https://codeforces.com/problemset/problem/1/A). Now it's finally getting repaved.
The square still has a rectangular shape of n × m meters. However, the picture is about to get more complicated now. Let a_{i,j} be the j-th square in the i-th row of the pavement.
You are given the picture of the squares:
* if a_{i,j} = "*", then the j-th square in the i-th row should be black;
* if a_{i,j} = ".", then the j-th square in the i-th row should be white.
The black squares are paved already. You have to pave the white squares. There are two options for pavement tiles:
* 1 × 1 tiles — each tile costs x burles and covers exactly 1 square;
* 1 × 2 tiles — each tile costs y burles and covers exactly 2 adjacent squares of the same row. Note that you are not allowed to rotate these tiles or cut them into 1 × 1 tiles.
You should cover all the white squares, no two tiles should overlap and no black squares should be covered by tiles.
What is the smallest total price of the tiles needed to cover all the white squares?
Input
The first line contains a single integer t (1 ≤ t ≤ 500) — the number of testcases. Then the description of t testcases follow.
The first line of each testcase contains four integers n, m, x and y (1 ≤ n ≤ 100; 1 ≤ m ≤ 1000; 1 ≤ x, y ≤ 1000) — the size of the Theatre square, the price of the 1 × 1 tile and the price of the 1 × 2 tile.
Each of the next n lines contains m characters. The j-th character in the i-th line is a_{i,j}. If a_{i,j} = "*", then the j-th square in the i-th row should be black, and if a_{i,j} = ".", then the j-th square in the i-th row should be white.
It's guaranteed that the sum of n × m over all testcases doesn't exceed 10^5.
Output
For each testcase print a single integer — the smallest total price of the tiles needed to cover all the white squares in burles.
Example
Input
4
1 1 10 1
.
1 2 10 1
..
2 1 10 1
.
.
3 3 3 7
..*
*..
.*.
Output
10
1
20
18
Note
In the first testcase you are required to use a single 1 × 1 tile, even though 1 × 2 tile is cheaper. So the total price is 10 burles.
In the second testcase you can either use two 1 × 1 tiles and spend 20 burles or use a single 1 × 2 tile and spend 1 burle. The second option is cheaper, thus the answer is 1.
The third testcase shows that you can't rotate 1 × 2 tiles. You still have to use two 1 × 1 tiles for the total price of 20.
In the fourth testcase the cheapest way is to use 1 × 1 tiles everywhere. The total cost is 6 ⋅ 3 = 18.
|
cases=input()
for i in range(0,int(cases)):
inss=input()
list=inss.split(' ')
n=int(list[0])
m=int(list[1])
x=int(list[2])
y=int(list[3])
price=0
if 2*x > y:
lame=True
else:
lame=False
for count in range(0,n):
data=input()
###print(data)
###list1=data.split('')
###print(list1)
if lame:
##print("lame yes")
sing=0
doub=0
lolz=False
for item in data:
##print(item)
if lolz:
if item=='.':
doub=doub+1
sing=sing-1
lolz=False
else:
lolz=False
else:
if item=='.':
sing=sing+1
lolz=True
##print(doub,sing)
price=price+(doub*y+sing*x)
##print(price,"1")
else:
##print("lame no")
for item in data:
if item=='.':
price=price+x
print(price)
|
There are many freight trains departing from Kirnes planet every day. One day on that planet consists of h hours, and each hour consists of m minutes, where m is an even number. Currently, there are n freight trains, and they depart every day at the same time: i-th train departs at h_i hours and m_i minutes.
The government decided to add passenger trams as well: they plan to add a regular tram service with half-hour intervals. It means that the first tram of the day must depart at 0 hours and t minutes, where 0 ≤ t < {m \over 2}, the second tram departs m \over 2 minutes after the first one and so on. This schedule allows exactly two passenger trams per hour, which is a great improvement.
To allow passengers to board the tram safely, the tram must arrive k minutes before. During the time when passengers are boarding the tram, no freight train can depart from the planet. However, freight trains are allowed to depart at the very moment when the boarding starts, as well as at the moment when the passenger tram departs. Note that, if the first passenger tram departs at 0 hours and t minutes, where t < k, then the freight trains can not depart during the last k - t minutes of the day.
<image> A schematic picture of the correct way to run passenger trams. Here h=2 (therefore, the number of passenger trams is 2h=4), the number of freight trains is n=6. The passenger trams are marked in red (note that the spaces between them are the same). The freight trains are marked in blue. Time segments of length k before each passenger tram are highlighted in red. Note that there are no freight trains inside these segments.
Unfortunately, it might not be possible to satisfy the requirements of the government without canceling some of the freight trains. Please help the government find the optimal value of t to minimize the number of canceled freight trains in case all passenger trams depart according to schedule.
Input
The first line of input contains four integers n, h, m, k (1 ≤ n ≤ 100 000, 1 ≤ h ≤ 10^9, 2 ≤ m ≤ 10^9, m is even, 1 ≤ k ≤ {m \over 2}) — the number of freight trains per day, the number of hours and minutes on the planet, and the boarding time for each passenger tram.
n lines follow, each contains two integers h_i and m_i (0 ≤ h_i < h, 0 ≤ m_i < m) — the time when i-th freight train departs. It is guaranteed that no freight trains depart at the same time.
Output
The first line of output should contain two integers: the minimum number of trains that need to be canceled, and the optimal starting time t. Second line of output should contain freight trains that need to be canceled.
Examples
Input
2 24 60 15
16 0
17 15
Output
0 0
Input
2 24 60 16
16 0
17 15
Output
1 0
2
Note
In the first test case of the example the first tram can depart at 0 hours and 0 minutes. Then the freight train at 16 hours and 0 minutes can depart at the same time as the passenger tram, and the freight train at 17 hours and 15 minutes can depart at the same time as the boarding starts for the upcoming passenger tram.
In the second test case of the example it is not possible to design the passenger tram schedule without cancelling any of the freight trains: if t ∈ [1, 15], then the freight train at 16 hours and 0 minutes is not able to depart (since boarding time is 16 minutes). If t = 0 or t ∈ [16, 29], then the freight train departing at 17 hours 15 minutes is not able to depart. However, if the second freight train is canceled, one can choose t = 0. Another possible option is to cancel the first train and choose t = 13.
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, t, id;
} a[200002];
int n, h, m, k, i, j;
int read() {
char c = getchar();
int w = 0;
while (c < '0' || c > '9') c = getchar();
while (c <= '9' && c >= '0') {
w = w * 10 + c - '0';
c = getchar();
}
return w;
}
int cmp1(const node &a, const node &b) {
if (a.x == b.x) return a.t < b.t;
return a.x < b.x;
}
int cmp2(const node &a, const node &b) { return a.t < b.t; }
int main() {
n = read();
h = read();
m = read();
k = read();
for (i = 1; i <= n; i++) {
a[i].x = read();
a[i].t = read() % (m / 2);
a[i].id = i;
}
sort(a + 1, a + n + 1, cmp2);
for (i = 1; i <= n; i++) a[n + i] = (node){0, a[i].t + m / 2, a[i].id};
int ans = 1 << 30, tim, l, r;
for (i = n + 1, j = 1; i <= 2 * n; i++) {
while (a[i].t - a[j].t >= k && j <= 2 * n) j++;
if (i - j < ans) ans = i - j, l = j, r = i - 1, tim = a[i].t;
}
printf("%d %d\n", ans, tim % (m / 2));
if (ans != 0) {
for (i = l; i <= r; i++) printf("%d ", a[i].id);
puts("");
}
return 0;
}
|
Having bought his own apartment, Boris decided to paper the walls in every room. Boris's flat has n rooms, each of which has the form of a rectangular parallelepiped. For every room we known its length, width and height of the walls in meters (different rooms can have different dimensions, including height).
Boris chose m types of wallpaper to paper the walls of the rooms with (but it is not necessary to use all the types). Each type of wallpaper is sold in rolls of a fixed length and width (the length, naturally, shows how long the unfolded roll will be). In addition, for each type we know the price of one roll of this type.
The wallpaper of each type contains strips running along the length of the roll. When gluing the strips must be located strictly vertically (so the roll cannot be rotated, even if the length is less than the width). Besides, a roll can be cut in an arbitrary manner, but the joints of glued pieces should also be vertical. In addition, each room should be papered by only one type of wallpaper. And pieces of the same roll cannot be used to paper different rooms. That is, for each room the rolls are purchased separately. Also, some rolls can be used not completely.
After buying an apartment Boris is short of cash, so he wants to spend the minimum money on wallpaper. Help him.
Input
The first line contains a positive integer n (1 ≤ n ≤ 500) — the number of rooms in Boris's apartment.
Each of the next n lines contains three space-separated positive integers — the length, width and height of the walls in a given room in meters, respectively.
The next line contains a positive integer m (1 ≤ m ≤ 500) — the number of available wallpaper types.
Each of the following m lines contains three space-separated positive integers — the length and width in meters of a given wallpaper and the price of one roll, respectively.
All numbers in the input data do not exceed 500. It is guaranteed that each room can be papered using these types of wallpaper.
Output
Print a single number — the minimum total cost of the rolls.
Examples
Input
1
5 5 3
3
10 1 100
15 2 320
3 19 500
Output
640
Note
Note to the sample:
The total length of the walls (the perimeter) of the room is 20 m.
One roll of the first type can be cut into pieces to get three vertical 1 meter wide strips, ergo you need 7 rolls of this type, the price equals 700.
A roll of the second type can be cut into pieces to get five 2 meter wide strips, we need 2 rolls, the price is 640.
One roll of the third type can immediately paper 19 meters out of 20, but we cannot use other types and we have to buy a second roll, the price is 1000.
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const long double pi = acos(-1.0);
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
int xabs(int a) { return a > 0 ? a : -a; }
int getCost(int l, int w, int h, int rl, int rw, int cost) {
int cnt = 1;
int p = 2 * (l + w);
int crl = rl;
int pok = 0;
while (true) {
if (crl >= h)
crl -= h;
else {
++cnt;
crl = rl;
crl -= h;
}
pok += rw;
if (pok >= p) break;
}
return cnt * cost;
}
int main() {
int n;
cin >> n;
vector<int> l(n), w(n), h(n);
for (int i = 0; i < n; ++i) cin >> l[i] >> w[i] >> h[i];
int m;
cin >> m;
vector<int> rl(m), rw(m), cost(m);
for (int i = 0; i < m; ++i) cin >> rl[i] >> rw[i] >> cost[i];
int sum = 0;
for (int i = 0; i < n; ++i) {
int msum = -1;
for (int j = 0; j < m; ++j) {
if (rl[j] >= h[i]) {
int s = getCost(l[i], w[i], h[i], rl[j], rw[j], cost[j]);
if (msum == -1 || s < msum) msum = s;
}
}
sum += msum;
}
cout << sum << endl;
return 0;
}
|
A famous gang of pirates, Sea Dogs, has come back to their hideout from one of their extravagant plunders. They want to split their treasure fairly amongst themselves, that is why You, their trusted financial advisor, devised a game to help them:
All of them take a sit at their round table, some of them with the golden coins they have just stolen. At each iteration of the game if one of them has equal or more than 2 coins, he is eligible to the splitting and he gives one coin to each pirate sitting next to him. If there are more candidates (pirates with equal or more than 2 coins) then You are the one that chooses which one of them will do the splitting in that iteration. The game ends when there are no more candidates eligible to do the splitting.
Pirates can call it a day, only when the game ends. Since they are beings with a finite amount of time at their disposal, they would prefer if the game that they are playing can end after finite iterations, and if so, they call it a good game. On the other hand, if no matter how You do the splitting, the game cannot end in finite iterations, they call it a bad game. Can You help them figure out before they start playing if the game will be good or bad?
Input
The first line of input contains two integer numbers n and k (1 ≤ n ≤ 10^{9}, 0 ≤ k ≤ 2⋅10^5), where n denotes total number of pirates and k is the number of pirates that have any coins.
The next k lines of input contain integers a_i and b_i (1 ≤ a_i ≤ n, 1 ≤ b_i ≤ 10^{9}), where a_i denotes the index of the pirate sitting at the round table (n and 1 are neighbours) and b_i the total number of coins that pirate a_i has at the start of the game.
Output
Print 1 if the game is a good game: There is a way to do the splitting so the game ends after finite number of iterations.
Print -1 if the game is a bad game: No matter how You do the splitting the game does not end in finite number of iterations.
Examples
Input
4 2
1 2
2 2
Output
1
Input
6 2
2 3
4 1
Output
1
Input
3 2
1 1
2 2
Output
-1
Note
In the third example the game has no end, because You always only have only one candidate, after whose splitting you end up in the same position as the starting one.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
long long n, k;
cin >> n >> k;
long long tot = 0;
long long sumPos = 0;
for (int _ = 0; _ < (k); ++_) {
long long pos, num;
cin >> pos >> num;
pos--;
sumPos += pos * num;
sumPos %= n;
tot += num;
}
if (tot > n) {
cout << -1 << endl;
} else if (tot < n) {
cout << 1 << endl;
} else {
long long expected = (n - 1) * n / 2;
if (expected % n == sumPos)
cout << 1 << endl;
else
cout << -1 << endl;
}
}
|
You are given a tree with each vertex coloured white, black or grey. You can remove elements from the tree by selecting a subset of vertices in a single connected component and removing them and their adjacent edges from the graph. The only restriction is that you are not allowed to select a subset containing a white and a black vertex at once.
What is the minimum number of removals necessary to remove all vertices from the tree?
Input
Each test contains multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100 000), denoting the number of test cases, followed by a description of the test cases.
The first line of each test case contains an integer n (1 ≤ n ≤ 200 000): the number of vertices in the tree.
The second line of each test case contains n integers a_v (0 ≤ a_v ≤ 2): colours of vertices. Gray vertices have a_v=0, white have a_v=1, black have a_v=2.
Each of the next n-1 lines contains two integers u, v (1 ≤ u, v ≤ n): tree edges.
The sum of all n throughout the test is guaranteed to not exceed 200 000.
Output
For each test case, print one integer: the minimum number of operations to solve the problem.
Example
Input
4
2
1 1
1 2
4
1 2 1 2
1 2
2 3
3 4
5
1 1 0 1 2
1 2
2 3
3 4
3 5
8
1 2 1 2 2 2 1 2
1 3
2 3
3 4
4 5
5 6
5 7
5 8
Output
1
3
2
3
Note
<image>
In the first test case, both vertices are white, so you can remove them at the same time.
<image>
In the second test case, three operations are enough. First, we need to remove both black vertices (2 and 4), then separately remove vertices 1 and 3. We can't remove them together because they end up in different connectivity components after vertex 2 is removed.
<image>
In the third test case, we can remove vertices 1, 2, 3, 4 at the same time, because three of them are white and one is grey. After that, we can remove vertex 5.
<image>
In the fourth test case, three operations are enough. One of the ways to solve the problem is to remove all black vertices at once, then remove white vertex 7, and finally, remove connected white vertices 1 and 3.
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool mini(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
bool maxi(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int N = 2e5 + 5;
const int oo = 1e9;
vector<int> adj[N];
int dp[N][2];
int a[N];
int n, ans;
void dfs(int u, int p = -1) {
for (int v : adj[u])
if (v != p) dfs(v, u);
dp[u][0] = dp[u][1] = oo;
if (a[u] == 0) {
int d = oo;
for (int val = 0; val < 2; val++) {
dp[u][val] = 0;
pair<int, int> tmp = make_pair(0, 0);
for (int v : adj[u])
if (v != p) {
int res = min(dp[v][0] + val, dp[v][1] + (!val));
maxi(dp[u][val], res);
maxi(tmp.second, res);
if (tmp.second > tmp.first) swap(tmp.second, tmp.first);
}
mini(d, tmp.first + tmp.second);
}
maxi(ans, d);
} else {
int val = a[u] - 1;
dp[u][val] = 0;
pair<int, int> tmp = make_pair(0, 0);
for (int v : adj[u])
if (v != p) {
int res = min(dp[v][0] + val, dp[v][1] + (!val));
maxi(dp[u][val], res);
maxi(tmp.second, res);
if (tmp.second > tmp.first) swap(tmp.second, tmp.first);
}
maxi(ans, tmp.first + tmp.second);
}
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
adj[i].clear();
cin >> a[i];
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
ans = 0;
dfs(1);
cout << ((ans + 1) >> 1) + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
|
The hobbits Frodo and Sam are carrying the One Ring to Mordor. In order not to be spotted by orcs, they decided to go through the mountains.
The mountain relief can be represented as a polyline with n points (x_i, y_i), numbered from 1 to n (x_i < x_{i + 1} for 1 ≤ i ≤ n - 1). Hobbits start their journey at the point (x_1, y_1) and should reach the point (x_n, y_n) to complete their mission.
The problem is that there is a tower with the Eye of Sauron, which watches them. The tower is located at the point (x_n, y_n) and has the height H, so the Eye is located at the point (x_n, y_n + H). In order to complete the mission successfully, the hobbits have to wear cloaks all the time when the Sauron Eye can see them, i. e. when there is a direct line from the Eye to the hobbits which is not intersected by the relief.
The hobbits are low, so their height can be considered negligibly small, but still positive, so when a direct line from the Sauron Eye to the hobbits only touches the relief, the Eye can see them.
<image> The Sauron Eye can't see hobbits when they are in the left position, but can see them when they are in the right position.
The hobbits do not like to wear cloaks, so they wear them only when they can be spotted by the Eye. Your task is to calculate the total distance the hobbits have to walk while wearing cloaks.
Input
The first line of the input contains two integers n and H (2 ≤ n ≤ 2 ⋅ 10^5; 1 ≤ H ≤ 10^4) — the number of vertices in polyline and the tower height.
The next n lines contain two integers x_i, y_i each (0 ≤ x_i ≤ 4 ⋅ 10^5; 0 ≤ y_i ≤ 10^4) — the coordinates of the polyline vertices. It is guaranteed that x_i < x_{i + 1} for 1 ≤ i ≤ n - 1.
Output
Print one real number — the total distance the hobbits have to walk while wearing cloaks. Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6} — formally, if your answer is a, and the jury's answer is b, your answer will be accepted if (|a - b|)/(max(1, b)) ≤ 10^{-6}.
Examples
Input
6 10
10 40
20 10
25 30
30 15
50 15
65 30
Output
70.4034587602
Input
9 5
0 0
5 10
15 10
20 0
25 11
30 0
35 10
50 10
60 5
Output
27.2787986124
Input
2 10000
0 10000
400000 0
Output
400124.9804748512
|
#include<bits/stdc++.h>
using namespace std;
#define debug printf("%d %s\n",__LINE__,__FUNCTION__);fflush(stdout)
using ll=long long;using i64=long long;using db=double;
using u32=unsigned int;using u64=unsigned long long;using db=double;
using pii=pair<db,db>;using vi=vector<int>;
using qi=queue<int>;using pqi=priority_queue<int>;using si=set<int>;
#define pb push_back
#define mk make_pair
#define ins insert
#define era erase
#define fi first
#define se second
#define lowbit(x) x&-x
#define ALL(a) a.begin(),a.end()
const int INF=0x3f3f3f3f;
const ll INFLL=0x3f3f3f3f3f3f3f3f;
const double PI=acos(-1.0);
template<class T>inline bool chkmin(T&a,T b){return b<a?a=b,true:false;}
template<class T>inline bool chkmax(T&a,T b){return a<b?a=b,true:false;}
int _w,_t;FILE* _f;
db slo(pii na,pii nb){
if(na.fi==nb.fi){
return (db)INF;
}
else{
return (db)(nb.se-na.se)/(nb.fi-na.fi);
}
}
db sq(db u){
return u*u;
}
db dis(pii na,pii nb){
return sqrt(sq(nb.fi-na.fi)+sq(nb.se-na.se));
}
pii its(pii naa,pii nab,pii nba,pii nbb){
db l=naa.fi,r=nab.fi;
while(r-l>1e-10){
db mid=(l+r)/2;
if(slo(mk(mid,naa.se+(mid-naa.fi)*slo(naa,nab)),nba)>slo(nba,nbb)){
r=mid;
}
else{
l=mid;
}
}
return mk(l,naa.se+(l-naa.fi)*slo(naa,nab));
}
const int N=2e5+5;
int n,h;
pii nd[N];
db ans;
void solve(){
scanf("%d%d",&n,&h);
for(int i=1;i<=n;i++){
scanf("%lf%lf",&nd[i].fi,&nd[i].se);
}
for(int i=1;i<n;i++){
ans+=dis(nd[i],nd[i+1]);
}
nd[n+1]=mk(nd[n].fi,nd[n].se+h);
int pos=n,ite=n;
while(pos>1){
while(pos>1&&slo(nd[pos-1],nd[pos])<=slo(nd[pos],nd[n+1])){
--pos;
}
ite=pos-1;
while(ite>0&&slo(nd[ite],nd[pos])>slo(nd[pos],nd[n+1])){
ans-=dis(nd[ite],nd[ite+1]);
--ite;
}
if(!ite){
break;
}
ans-=dis(its(nd[ite],nd[ite+1],nd[pos],nd[n+1]),nd[ite+1]);
pos=ite;
}
printf("%.10lf\n",ans);
}
int main(){
#ifdef MULTI_CASES
_w=scanf("%d",&_t);while(_t--)
#endif
solve();
return 0;
}
|
You are given two integers n and k. You are asked to choose maximum number of distinct integers from 1 to n so that there is no subset of chosen numbers with sum equal to k.
A subset of a set is a set that can be obtained from initial one by removing some (possibly all or none) elements of it.
Input
The first line contains the number of test cases T (1 ≤ T ≤ 100).
Each of the next T lines contains two integers n and k (1 ≤ k ≤ n ≤ 1000) — the description of test cases.
Output
For each test case output two lines. In the first line output a single integer m — the number of chosen integers.
In the second line output m distinct integers from 1 to n — the chosen numbers.
If there are multiple answers, print any. You can print the numbers in any order.
Example
Input
3
3 2
5 3
1 1
Output
2
3 1
3
4 5 2
0
|
t=int(input())
for i in range(t):
n,k = map(int,input().split())
ans=[]
if n==1 and k==1:
print(0)
continue
else:
if k%2==0:
for j in range(k//2,k):
ans.append(j)
for j in range(k+1,n+1):
ans.append(j)
else:
for j in range(k//2+1,k):
ans.append(j)
for j in range(k+1,n+1):
ans.append(j)
print(len(ans))
print(*ans)
|
In Fire City, there are n intersections and m one-way roads. The i-th road goes from intersection a_i to b_i and has length l_i miles.
There are q cars that may only drive along those roads. The i-th car starts at intersection v_i and has an odometer that begins at s_i, increments for each mile driven, and resets to 0 whenever it reaches t_i. Phoenix has been tasked to drive cars along some roads (possibly none) and return them to their initial intersection with the odometer showing 0.
For each car, please find if this is possible.
A car may visit the same road or intersection an arbitrary number of times. The odometers don't stop counting the distance after resetting, so odometers may also be reset an arbitrary number of times.
Input
The first line of the input contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5; 1 ≤ m ≤ 2 ⋅ 10^5) — the number of intersections and the number of roads, respectively.
Each of the next m lines contain three integers a_i, b_i, and l_i (1 ≤ a_i, b_i ≤ n; a_i ≠ b_i; 1 ≤ l_i ≤ 10^9) — the information about the i-th road. The graph is not necessarily connected. It is guaranteed that between any two intersections, there is at most one road for each direction.
The next line contains an integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of cars.
Each of the next q lines contains three integers v_i, s_i, and t_i (1 ≤ v_i ≤ n; 0 ≤ s_i < t_i ≤ 10^9) — the initial intersection of the i-th car, the initial number on the i-th odometer, and the number at which the i-th odometer resets, respectively.
Output
Print q answers. If the i-th car's odometer may be reset to 0 by driving through some roads (possibly none) and returning to its starting intersection v_i, print YES. Otherwise, print NO.
Examples
Input
4 4
1 2 1
2 3 1
3 1 2
1 4 3
3
1 1 3
1 2 4
4 0 1
Output
YES
NO
YES
Input
4 5
1 2 1
2 3 1
3 1 2
1 4 1
4 3 2
2
1 2 4
4 3 5
Output
YES
YES
Note
The illustration for the first example is below:
<image>
In the first query, Phoenix can drive through the following cities: 1 → 2 → 3 → 1 → 2 → 3 → 1. The odometer will have reset 3 times, but it displays 0 at the end.
In the second query, we can show that there is no way to reset the odometer to 0 and return to intersection 1.
In the third query, the odometer already displays 0, so there is no need to drive through any roads.
Below is the illustration for the second example:
<image>
|
using namespace std;
#define visual
#ifdef visual
#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#include <assert.h>
#include <functional>
#include <math.h>
#include <string>
#include <ctime>
#endif
#ifndef visual
#include <bits/stdc++.h>
#endif
typedef long long ll;
vector<vector<pair<long long, long long>> > g;
vector<vector<pair<long long, long long>> > h;
vector<long long> seen;
vector<long long> seen2;
vector<long long> dist;
vector<long long> gcds;
vector<long long> par;
vector<long long> comp;
long long cur = 0;
long long gcd(long long a, long long b){
if(a ==0 || b == 0) return a+b;
if(a < b) return gcd(b, a);
return gcd(a%b, b);
}
void dfs(long long v, long long p, long long d){
if(seen[v]){
//gcds[cur] = gcd(gcds[cur], d+dist[v]);
return;
}
par[v] = cur;
dist[v] = d;
seen[v] = true;
for(long long i=0; i<g[v].size(); i++){
long long u = g[v][i].first;
if(comp[u] != comp[v]) continue;
dfs(u, v, d+g[v][i].second);
}
}
void dfs2(long long v, long long p, long long d){
gcds[cur] = gcd(gcds[cur], d+dist[v]);
if(seen2[v]){
return;
}
par[v] = cur;
seen2[v] = true;
for(long long i=0; i<h[v].size(); i++){
long long u = h[v][i].first;
if(comp[u] != comp[v]) continue;
dfs2(u, v, d+h[v][i].second);
}
}
int SZ = 0; //the number of sccs
vector<int> ID; //id[v] is the scc id of v
int LS = 0;
vector<int> L;
vector<vector<int>> R, gg;
void dfs1(int v) {
if (ID[v]) return;
ID[v] = 1;
for (auto u : gg[v])
dfs1(u);
L[LS++] = v;
}
void dfs2(int v, int r) {
if (~ID[v]) return;
ID[v] = r;
for (int u : R[v])
dfs2(u, r);
}
//First: list of vertices in each components, in topological order.
//second: graph shrinking each SCC to a vertex, should be a DAG in topological order.
pair<vector< vector<int> >, vector<vector<int> > > scc() {
int n = g.size();
R.resize(n), ID.resize(n), L.resize(n);
for (int i = 0; i < n; i++) {
for (auto u : gg[i]) {
R[u].push_back(i);
}
}
for (int v = 0; v < n; ++v)
dfs1(v);
fill(ID.begin(), ID.end(), -1);
int mx = 0;
for (int i = n - 1; i >= 0; --i) {
if (ID[L[i]] == -1)
dfs2(L[i], SZ++);
}
for (int i = 0; i < n; i++) {
mx = max(mx, ID[i]);
}
vector<vector<int>> A(mx+1);
vector<vector<int>> B(mx+1);
for (int u = 0; u < n; ++u) {
A[ID[u]].push_back(u);
for (int v : gg[u])
if (ID[u] != ID[v])
B[ID[u]].push_back(ID[v]);
}
for (int i = 0; i < SZ; ++i) {
sort(B[i].begin(), B[i].end());
B[i].erase(unique(B[i].begin(), B[i].end()), B[i].end());
}
return { A, B };
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
long long n, m, q;
cin >> n >> m;
g = vector<vector<pair<long long, long long>> >(n);
h = vector<vector<pair<long long, long long>> >(n);
gg = vector<vector<int> >(n);
for(long long i=0; i<m; i++){
long long x, y, l;
cin >> x >> y >> l;
x--, y--;
g[x].push_back({y, l});
gg[x].push_back(y);
h[y].push_back({x, l});
}
vector< vector<int> > aa = scc().first;
comp = vector<long long>(n, false);
int ii = 0;
for(vector<int> a : aa){
for(int z : a){
comp[z] = ii;
}
ii++;
}
seen = vector<long long>(n, false);
seen2 = vector<long long>(n, false);
dist = vector<long long>(n, false);
gcds = vector<long long>(n, false);
par = vector<long long>(n, false);
for(long long i=0; i<n; i++){
if(!seen[i]){
cur = i;
dfs(i, -1, 0);
dfs2(i, -1, 0);
}
}
cin >> q;
for(long long i=0; i<q; i++){
long long v, s, t;
cin >> v >> s >> t;
v--;
if(s == 0 || s % gcd(gcds[par[v]], t) == 0){
cout << "YES" << endl;
}else{
cout << "NO" << endl;
}
}
}
|
This is the hard version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.
A permutation of 1, 2, …, n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.
Recall that the number of inversions in a permutation a_1, a_2, …, a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.
Let p and q be two permutations of 1, 2, …, n. Find the number of permutation pairs (p,q) that satisfy the following conditions:
* p is lexicographically smaller than q.
* the number of inversions in p is greater than the number of inversions in q.
Print the number of such pairs modulo mod. Note that mod may not be a prime.
Input
The only line contains two integers n and mod (1≤ n≤ 500, 1≤ mod≤ 10^9).
Output
Print one integer, which is the answer modulo mod.
Example
Input
4 403458273
Output
17
Note
The following are all valid pairs (p,q) when n=4.
* p=[1,3,4,2], q=[2,1,3,4],
* p=[1,4,2,3], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,3,4],
* p=[1,4,3,2], q=[2,1,4,3],
* p=[1,4,3,2], q=[2,3,1,4],
* p=[1,4,3,2], q=[3,1,2,4],
* p=[2,3,4,1], q=[3,1,2,4],
* p=[2,4,1,3], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,2,4],
* p=[2,4,3,1], q=[3,1,4,2],
* p=[2,4,3,1], q=[3,2,1,4],
* p=[2,4,3,1], q=[4,1,2,3],
* p=[3,2,4,1], q=[4,1,2,3],
* p=[3,4,1,2], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,2,3],
* p=[3,4,2,1], q=[4,1,3,2],
* p=[3,4,2,1], q=[4,2,1,3].
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
#define alpha ios::sync_with_stdio(0); cin.tie(0);
const int B = 130000;
int w[2][2*B+5], s[2][2*B+5], ans[505];
void solve() {
int n, MOD; cin >> n >> MOD;
w[0][B] = s[0][B] = 1;
for(int i=B; i<=2*B; i++) s[0][i] = 1;
for(int i=1; i<=n; i++) {
int curs=1, I=i&1, J=I^1;
memset(w[I], 0, sizeof(w[I])), memset(s[I], 0, sizeof(s[I]));
int u=i*(i-1)/2;
for(int j=-u+B; j<=u+B; j++) {
w[I][j]=curs;
curs=(0ll + curs-s[J][j]+s[J][j-i]+s[J][j+i]-s[J][j]+2ll*MOD) % MOD;
}
for(int j=B-i*(i-1)/2, v=(i+2)*(i+1)/2+B; j<=v; j++) {
s[I][j] = (s[I][j-1] + w[I][j])%MOD;
}
for(int j=1; j<i; j++) {
ans[i] = (ans[i] + 1ll*(s[J][(i+1)*i/2+B]-s[J][j+B]+MOD)%MOD*(i-j))%MOD;
}
}
for(int i=2; i<=n; i++) {
ans[i] = (ans[i] + 1ll*i*ans[i-1]) % MOD;
}
cout << ans[n];
}
int main(int argc, char const *argv[])
{
alpha;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("error.txt", "w", stderr);
freopen("output.txt", "w", stdout);
#endif
int t=1;
// cin >> t;
while(t--) {
solve();
cout << '\n';
}
cerr<<"time taken : "<<(float)clock()/CLOCKS_PER_SEC<<" secs"<<endl;
return 0;
}
|
Input
The input contains two integers a1, a2 (0 ≤ ai ≤ 109), separated by a single space.
Output
Output a single integer.
Examples
Input
3 14
Output
44
Input
27 12
Output
48
Input
100 200
Output
102
|
import java.math.BigInteger;
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String a=scan.next();
String b=scan.next();
int max=Math.max(a.length(), b.length());
String w="";
String p="";
for (int i = b.length()-1; i>=0; i--) {
p+=b.charAt(i);
}
BigInteger num1=new BigInteger(a);
BigInteger num2=new BigInteger(p);
System.out.println(num1.add(num2));
}
}
|
Berland starts to seize the initiative on the war with Flatland. To drive the enemy from their native land, the berlanders need to know exactly how many more flatland soldiers are left in the enemy's reserve. Fortunately, the scouts captured an enemy in the morning, who had a secret encrypted message with the information the berlanders needed so much.
The captured enemy had an array of positive integers. Berland intelligence have long been aware of the flatland code: to convey the message, which contained a number m, the enemies use an array of integers a. The number of its subarrays, in which there are at least k equal numbers, equals m. The number k has long been known in the Berland army so General Touristov has once again asked Corporal Vasya to perform a simple task: to decipher the flatlanders' message.
Help Vasya, given an array of integers a and number k, find the number of subarrays of the array of numbers a, which has at least k equal numbers.
Subarray a[i... j] (1 ≤ i ≤ j ≤ n) of array a = (a1, a2, ..., an) is an array, made from its consecutive elements, starting from the i-th one and ending with the j-th one: a[i... j] = (ai, ai + 1, ..., aj).
Input
The first line contains two space-separated integers n, k (1 ≤ k ≤ n ≤ 4·105), showing how many numbers an array has and how many equal numbers the subarrays are required to have, correspondingly.
The second line contains n space-separated integers ai (1 ≤ ai ≤ 109) — elements of the array.
Output
Print the single number — the number of such subarrays of array a, that they have at least k equal integers.
Please do not use the %lld specifier to read or write 64-bit integers in С++. In is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4 2
1 2 1 2
Output
3
Input
5 3
1 2 1 1 3
Output
2
Input
3 1
1 1 1
Output
6
Note
In the first sample are three subarrays, containing at least two equal numbers: (1,2,1), (2,1,2) and (1,2,1,2).
In the second sample are two subarrays, containing three equal numbers: (1,2,1,1,3) and (1,2,1,1).
In the third sample any subarray contains at least one 1 number. Overall they are 6: (1), (1), (1), (1,1), (1,1) and (1,1,1).
|
import java.util.*;
public class Main {
public static void main(String [] args){
Scanner in=new Scanner(System.in);
int n=in.nextInt();
int k=in.nextInt();
int array[]=new int[n];
for(int i=0;i<n;i++)array[i]=in.nextInt();
int leftPtr=0;
int rightPtr=0;
HashMap<Integer,Integer>map=new HashMap<Integer,Integer>();
long ans=0;
boolean move=true;
while(leftPtr < n && move){
Integer a=map.get(array[rightPtr]);
long addVal=n-rightPtr;
int temp=1;
if(a==null)
map.put(array[rightPtr],1);
else {
map.put(array[rightPtr],a+1);temp=a+1;
}
if(temp>=k){
boolean flag=true;
long prev=leftPtr;
while(flag){
Integer x=map.get(array[leftPtr]);
map.put(array[leftPtr],x-1);leftPtr++;
if(x==k){
flag=false;ans+=(leftPtr-prev)*addVal;
}
//System.out.println(leftPtr+" "+rightPtr+" "+ans);
}
}
rightPtr++;
if(rightPtr==n)move=false;
//System.out.println("1"+" "+rightPtr+" "+addVal+" "+temp+" "+move);
}
System.out.print(ans);
}
}
|
Furik loves writing all sorts of problems, especially such that he can't solve himself. You've got one of his problems, the one Furik gave to Rubik. And Rubik asks you to solve it.
There is integer n and array a, consisting of ten integers, indexed by numbers from 0 to 9. Your task is to count the number of positive integers with the following properties:
* the number's length does not exceed n;
* the number doesn't have leading zeroes;
* digit i (0 ≤ i ≤ 9) occurs in the number at least a[i] times.
Input
The first line contains integer n (1 ≤ n ≤ 100). The next line contains 10 integers a[0], a[1], ..., a[9] (0 ≤ a[i] ≤ 100) — elements of array a. The numbers are separated by spaces.
Output
On a single line print the remainder of dividing the answer to the problem by 1000000007 (109 + 7).
Examples
Input
1
0 0 0 0 0 0 0 0 0 1
Output
1
Input
2
1 1 0 0 0 0 0 0 0 0
Output
1
Input
3
1 1 0 0 0 0 0 0 0 0
Output
36
Note
In the first sample number 9 meets the requirements.
In the second sample number 10 meets the requirements.
In the third sample numbers 10, 110, 210, 120, 103 meet the requirements. There are other suitable numbers, 36 in total.
|
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static class FastReader {
BufferedReader br;
StringTokenizer root;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (root == null || !root.hasMoreTokens()) {
try {
root = new StringTokenizer(br.readLine());
} catch (Exception addd) {
addd.printStackTrace();
}
}
return root.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
long nextLong() {
return Long.parseLong(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (Exception addd) {
addd.printStackTrace();
}
return str;
}
}
public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
public static FastReader sc = new FastReader();
static int mod = (int) (1e9+7),MAX=(int) (2e5);
static List<Integer>[] edges;
static int[] a;
static int n;
static long[][] dp;
static long[] fac,inv;
public static void main(String[] args){
int n = sc.nextInt();
a = new int[10];
for(int i=0;i<=9;++i) a[i] = sc.nextInt();
dp = new long[10][n+1];
for(int i=0;i<dp.length;++i)
Arrays.fill(dp[i],-1);
precompute(n);
long ans = 0;
for(int i=1;i<=n;++i) {
ans = (ans + f(0,i))%mod;
}
out.print(ans);
out.close();
}
private static long f(int dig, int len) {
if(dig == 10) {
if(len == 0) return 1;
else return 0;
}
if(dp[dig][len] != -1) return dp[dig][len];
long ans = 0;
for(int i=a[dig];i<=len;++i) {
if(dig == 0) {
ans = (ans + ncr(len-1,i)*f(dig+1,len-i)%mod)%mod;
}else {
ans = (ans + ncr(len,i)*f(dig+1,len-i)%mod)%mod;
}
}
return dp[dig][len] = ans;
}
static void precompute(int n)
{
fac = new long[n+1];
inv = new long[n+1];
fac[0]=fac[1]=1;
for(int i=2;i<fac.length;i++)
{
fac[i]=fac[i-1]*i;
fac[i]%=mod;
}
inv[n]=pow(fac[n],(int) (mod-2));
for(int i=n-1;i>=0;i--)
{
inv[i]=inv[i+1]*(i+1);
inv[i]%=mod;
}
}
private static long pow(long a, int b) {
return BigInteger.valueOf(a).modPow(BigInteger.valueOf(b), BigInteger.valueOf(mod)).longValue();
}
private static long ncr(int n , int r) {
if(n < 0 || r < 0 || r > n) return 0;
return ((fac[n]*inv[r]%mod)*(inv[n-r]%mod))%mod;
}
}
|
There is a programming language in which every program is a non-empty sequence of "<" and ">" signs and digits. Let's explain how the interpreter of this programming language works. A program is interpreted using movement of instruction pointer (IP) which consists of two parts.
* Current character pointer (CP);
* Direction pointer (DP) which can point left or right;
Initially CP points to the leftmost character of the sequence and DP points to the right.
We repeat the following steps until the first moment that CP points to somewhere outside the sequence.
* If CP is pointing to a digit the interpreter prints that digit then CP moves one step according to the direction of DP. After that the value of the printed digit in the sequence decreases by one. If the printed digit was 0 then it cannot be decreased therefore it's erased from the sequence and the length of the sequence decreases by one.
* If CP is pointing to "<" or ">" then the direction of DP changes to "left" or "right" correspondingly. Then CP moves one step according to DP. If the new character that CP is pointing to is "<" or ">" then the previous character will be erased from the sequence.
If at any moment the CP goes outside of the sequence the execution is terminated.
It's obvious the every program in this language terminates after some steps.
We have a sequence s1, s2, ..., sn of "<", ">" and digits. You should answer q queries. Each query gives you l and r and asks how many of each digit will be printed if we run the sequence sl, sl + 1, ..., sr as an independent program in this language.
Input
The first line of input contains two integers n and q (1 ≤ n, q ≤ 105) — represents the length of the sequence s and the number of queries.
The second line contains s, a sequence of "<", ">" and digits (0..9) written from left to right. Note, that the characters of s are not separated with spaces.
The next q lines each contains two integers li and ri (1 ≤ li ≤ ri ≤ n) — the i-th query.
Output
For each query print 10 space separated integers: x0, x1, ..., x9 where xi equals the number of times the interpreter prints i while running the corresponding program. Print answers to the queries in the order they are given in input.
Examples
Input
7 4
1>3>22<
1 3
4 7
7 7
1 7
Output
0 1 0 1 0 0 0 0 0 0
2 2 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
2 3 2 1 0 0 0 0 0 0
|
import java.io.*;
import java.util.*;
public class B {
static boolean DBG = false;
FastScanner in;
PrintWriter out;
public void solve(String s){
if (DBG)
out.println(s);
int[] d = new int[10];
if (s.length() == 0 || s.charAt(0) == '<'){
prt(d); return;
}
char[] chs = s.toCharArray();
boolean[] v = new boolean[s.length()];
int i = 0, dir = 1, lastOpd = -1;
while (i<s.length() && i >=0){
if (chs[i] == '>'){
if (lastOpd != -1){
v[lastOpd] = true;
}
lastOpd = i;
dir = 1;
}else if (chs[i] == '<'){
if (lastOpd != -1){
v[lastOpd] = true;
}
lastOpd = i;
dir = -1;
}else{
int val = chs[i] - '0';
d[val]++;
chs[i]--;
if (chs[i] - '0' == -1){
v[i] = true;
}
lastOpd = -1;
}
i+= dir;
while (i<s.length() && i>=0 && v[i])
i+=dir;
}
prt(d);
}
private void prt(int[] a){
for (int i=0; i<a.length; i++)
out.print(a[i] + " ");
out.println();
}
public void solve() throws IOException {
int n = in.nextInt(), q = in.nextInt();
String exp = in.next();
while (q-- > 0){
int l = in.nextInt(), r = in.nextInt();
solve(exp.substring(l-1, r));
}
}
public void run() {
try{
in = new FastScanner(System.in);
out = new PrintWriter(System.out);
solve();
out.close();
}catch(IOException e){
e.printStackTrace();
}
}
class FastScanner {
BufferedReader br;
StringTokenizer st;
FastScanner(File f){
try{
br = new BufferedReader(new FileReader(f));
}catch(FileNotFoundException e){
e.printStackTrace();
}
}
FastScanner(InputStream in){
br = new BufferedReader(new InputStreamReader(in));
}
String next() {
while (st == null || !st.hasMoreTokens()){ // why using while loop here? because we need to handle multiple empty liens
try {
st = new StringTokenizer(br.readLine());
}catch(IOException e){
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt(){
return Integer.parseInt(next());
}
}
public static void main(String[] arg){
new B().run();
}
}
|
Vasya has found a piece of paper with a coordinate system written on it. There are n distinct squares drawn in this coordinate system. Let's number the squares with integers from 1 to n. It turned out that points with coordinates (0, 0) and (ai, ai) are the opposite corners of the i-th square.
Vasya wants to find such integer point (with integer coordinates) of the plane, that belongs to exactly k drawn squares. We'll say that a point belongs to a square, if the point is located either inside the square, or on its boundary.
Help Vasya find a point that would meet the described limits.
Input
The first line contains two space-separated integers n, k (1 ≤ n, k ≤ 50). The second line contains space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109).
It is guaranteed that all given squares are distinct.
Output
In a single line print two space-separated integers x and y (0 ≤ x, y ≤ 109) — the coordinates of the point that belongs to exactly k squares. If there are multiple answers, you are allowed to print any of them.
If there is no answer, print "-1" (without the quotes).
Examples
Input
4 3
5 1 3 4
Output
2 1
Input
3 1
2 4 1
Output
4 0
Input
4 50
5 1 10 2
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << endl; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << endl;
}
template <typename T, typename... hello>
void faltu(T arg, const hello &...rest) {
cerr << arg << ' ';
faltu(rest...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (n < k)
cout << -1 << endl;
else {
cout << a[n - k] << " " << a[n - k] << endl;
}
return 0;
}
|
Vova, the Ultimate Thule new shaman, wants to build a pipeline. As there are exactly n houses in Ultimate Thule, Vova wants the city to have exactly n pipes, each such pipe should be connected to the water supply. A pipe can be connected to the water supply if there's water flowing out of it. Initially Vova has only one pipe with flowing water. Besides, Vova has several splitters.
A splitter is a construction that consists of one input (it can be connected to a water pipe) and x output pipes. When a splitter is connected to a water pipe, water flows from each output pipe. You can assume that the output pipes are ordinary pipes. For example, you can connect water supply to such pipe if there's water flowing out from it. At most one splitter can be connected to any water pipe.
<image> The figure shows a 4-output splitter
Vova has one splitter of each kind: with 2, 3, 4, ..., k outputs. Help Vova use the minimum number of splitters to build the required pipeline or otherwise state that it's impossible.
Vova needs the pipeline to have exactly n pipes with flowing out water. Note that some of those pipes can be the output pipes of the splitters.
Input
The first line contains two space-separated integers n and k (1 ≤ n ≤ 1018, 2 ≤ k ≤ 109).
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single integer — the minimum number of splitters needed to build the pipeline. If it is impossible to build a pipeline with the given splitters, print -1.
Examples
Input
4 3
Output
2
Input
5 5
Output
1
Input
8 4
Output
-1
|
#include <bits/stdc++.h>
using namespace std;
long long n, tmp = 1;
int main() {
int k, x = 0;
cin >> n >> k;
while (k != x && tmp < n) {
x++;
tmp += k - x;
}
if (tmp >= n) {
cout << x << endl;
} else {
cout << -1 << endl;
}
}
|
SmallR is an archer. SmallR is taking a match of archer with Zanoes. They try to shoot in the target in turns, and SmallR shoots first. The probability of shooting the target each time is <image> for SmallR while <image> for Zanoes. The one who shoots in the target first should be the winner.
Output the probability that SmallR will win the match.
Input
A single line contains four integers <image>.
Output
Print a single real number, the probability that SmallR will win the match.
The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
1 2 1 2
Output
0.666666666667
|
#include <bits/stdc++.h>
using namespace std;
double a, b, c, d;
double ans = 0;
int main() {
cin >> a >> b >> c >> d;
ans = (a / b) / (1 - (1 - a / b) * (1 - c / d));
printf("%.12lf\n", ans);
}
|
Gerald has a friend, Pollard. Pollard is interested in lucky tickets (ticket is a sequence of digits). At first he thought that a ticket is lucky if between some its digits we can add arithmetic signs and brackets so that the result obtained by the arithmetic expression was number 100. But he quickly analyzed all such tickets and moved on to a more general question. Now he explores k-lucky tickets.
Pollard sais that a ticket is k-lucky if we can add arithmetic operation signs between its digits to the left or right of them (i.e., "+", "-", " × ") and brackets so as to obtain the correct arithmetic expression whose value would equal k. For example, ticket "224201016" is 1000-lucky as ( - 2 - (2 + 4)) × (2 + 0) + 1016 = 1000.
Pollard was so carried away by the lucky tickets that he signed up for a seminar on lucky tickets and, as far as Gerald knows, Pollard will attend it daily at 7 pm in some famous institute and will commute to it in the same tram for m days. In this tram tickets have eight digits. And Gerald wants to make a surprise for Pollard: each day Pollard will receive a tram k-lucky ticket. The conductor has already agreed to give Pollard certain tickets during all these m days and he only wants Gerald to tell him what kind of tickets to give out. In this regard, help Gerald pick exactly m distinct k-lucky tickets.
Input
The single line contains two integers k and m (0 ≤ k ≤ 104, 1 ≤ m ≤ 3·105).
Output
Print m lines. Each line must contain exactly 8 digits — the k-winning ticket. The tickets may begin with 0, all tickets must be distinct. If there are more than m distinct k-lucky tickets, print any m of them. It is guaranteed that at least m distinct k-lucky tickets exist. The tickets can be printed in any order.
Examples
Input
0 3
Output
00000000
00000001
00000002
Input
7 4
Output
00000007
00000016
00000017
00000018
|
#include <bits/stdc++.h>
using namespace std;
string pre[4] = {"", "0", "00", "000"};
int T[4] = {1, 10, 100, 1000};
int k, m;
bool v[10000];
int ndgt(int x) {
for (int i = 0; i < 3; ++i) {
if (x >= T[3 - i]) return i;
}
return 3;
}
bool print(int x, int s) {
int y = k < s ? s - k : k - s;
if (y < 10000 && !v[y]) {
cout << pre[ndgt(y)] << y << pre[ndgt(x)] << x << endl;
v[y] = true;
return true;
}
return false;
}
int calc(int t, int x) {
int p = 1;
int b = 0, a = 0, op_ = 0, z = x;
for (int i = 0; i < 4; ++i) {
int op = t % 4;
t /= 4;
b += (z % 10) * p;
if (op == 3) {
p *= 10;
} else {
switch (op_) {
case 0:
a = a + b;
break;
case 1:
a = a - b;
break;
case 2:
a = a * b;
break;
}
op_ = op, b = 0, p = 1;
}
z /= 10;
}
return a;
}
int rep[64];
int main1() {
int _1, _2;
while (cin >> _1 >> _2) cout << calc(_1, _2) << endl;
return 0;
}
int main() {
while (cin >> k >> m) {
for (int x = 0; x <= 9999 && m; ++x) {
memset(v, false, sizeof(v));
for (int cb = 0; cb < 64; ++cb) {
int s = calc(cb, x);
rep[cb] = s;
}
sort(rep, rep + 64);
if (print(x, rep[0])) m--;
for (int i = 1; i < 64 && m; ++i) {
if (rep[i] > rep[i - 1]) {
if (print(x, rep[i])) m--;
}
}
}
}
return 0;
}
int main2() {
string s;
int cnt = 0;
while (getline(cin, s)) {
cnt++;
if (s.size() != 8) {
cout << s << endl;
}
}
cout << "cnt=" << cnt << endl;
return 0;
}
|
A team of students from the city S is sent to the All-Berland Olympiad in Informatics. Traditionally, they go on the train. All students have bought tickets in one carriage, consisting of n compartments (each compartment has exactly four people). We know that if one compartment contain one or two students, then they get bored, and if one compartment contain three or four students, then the compartment has fun throughout the entire trip.
The students want to swap with other people, so that no compartment with students had bored students. To swap places with another person, you need to convince him that it is really necessary. The students can not independently find the necessary arguments, so they asked a sympathetic conductor for help. The conductor can use her life experience to persuade any passenger to switch places with some student.
However, the conductor does not want to waste time persuading the wrong people, so she wants to know what is the minimum number of people necessary to persuade her to change places with the students. Your task is to find the number.
After all the swaps each compartment should either have no student left, or have a company of three or four students.
Input
The first line contains integer n (1 ≤ n ≤ 106) — the number of compartments in the carriage. The second line contains n integers a1, a2, ..., an showing how many students ride in each compartment (0 ≤ ai ≤ 4). It is guaranteed that at least one student is riding in the train.
Output
If no sequence of swapping seats with other people leads to the desired result, print number "-1" (without the quotes). In another case, print the smallest number of people you need to persuade to swap places.
Examples
Input
5
1 2 2 4 3
Output
2
Input
3
4 1 1
Output
2
Input
4
0 3 0 4
Output
0
|
#include <bits/stdc++.h>
using namespace std;
int ans, a[10];
bool flag = true;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int ad;
cin >> ad;
a[ad]++;
}
ans += min(a[1], a[2]);
a[3] += min(a[1], a[2]);
int ad = min(a[1], a[2]);
a[1] -= ad;
a[2] -= ad;
if (a[1]) {
ad = (a[1] / 3) * 2;
ans += ad;
a[3] += a[1] / 3;
a[1] %= 3;
if (a[1] == 1 && a[3])
ans++;
else if (a[1] == 1 && a[4] >= 2)
ans += 2;
else if (a[1] == 1)
flag = false;
if (a[1] == 2 && a[3] >= a[1])
ans += a[1];
else if (a[1] == 2 && a[4])
ans += 2;
else if (a[1] == 2)
flag = false;
} else if (a[2]) {
ad = a[2] / 3 * 2;
ans += ad;
a[2] %= 3;
a[3] += ad;
if (a[2] == 2)
ans += 2;
else if (a[2] == 1 && a[4])
ans += 1;
else if (a[2] == 1 && a[3] >= 2)
ans += 2;
else if (a[2])
flag = false;
}
if (flag)
cout << ans << endl;
else
cout << -1;
return 0;
}
|
The cinema theater hall in Sereja's city is n seats lined up in front of one large screen. There are slots for personal possessions to the left and to the right of each seat. Any two adjacent seats have exactly one shared slot. The figure below shows the arrangement of seats and slots for n = 4.
<image>
Today it's the premiere of a movie called "Dry Hard". The tickets for all the seats have been sold. There is a very strict controller at the entrance to the theater, so all n people will come into the hall one by one. As soon as a person enters a cinema hall, he immediately (momentarily) takes his seat and occupies all empty slots to the left and to the right from him. If there are no empty slots, the man gets really upset and leaves.
People are not very constant, so it's hard to predict the order in which the viewers will enter the hall. For some seats, Sereja knows the number of the viewer (his number in the entering queue of the viewers) that will come and take this seat. For others, it can be any order.
Being a programmer and a mathematician, Sereja wonders: how many ways are there for the people to enter the hall, such that nobody gets upset? As the number can be quite large, print it modulo 1000000007 (109 + 7).
Input
The first line contains integer n (1 ≤ n ≤ 105). The second line contains n integers, the i-th integer shows either the index of the person (index in the entering queue) with the ticket for the i-th seat or a 0, if his index is not known. It is guaranteed that all positive numbers in the second line are distinct.
You can assume that the index of the person who enters the cinema hall is a unique integer from 1 to n. The person who has index 1 comes first to the hall, the person who has index 2 comes second and so on.
Output
In a single line print the remainder after dividing the answer by number 1000000007 (109 + 7).
Examples
Input
11
0 0 0 0 0 0 0 0 0 0 0
Output
1024
Input
6
0 3 1 0 0 0
Output
3
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000007;
const int maxn = 101010;
const long long inf = 2020202020202020202LL;
int n, a[maxn];
long long pow2[maxn], ans = 1, fact[maxn], revfact[maxn], lol = 1;
void upd_ans(long long t) { ans = (ans * t) % md; }
long long binpow(long long a, long long n) {
if (n == 0) return 1;
if (n % 2 == 1)
return (binpow(a, n - 1) * a) % md;
else {
long long b = binpow(a, n / 2);
return (b * b) % md;
}
}
void do_fact() {
fact[0] = 1;
revfact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = (i * fact[i - 1]) % md;
revfact[i] = binpow(fact[i], md - 2);
}
}
long long do_c(long long k, long long n) {
if (k < 0) return 0;
if (k > n) return 0;
long long r = 1;
r = r * fact[n];
r = (r * revfact[k]) % md;
r = (r * revfact[n - k]) % md;
return r;
}
long long doit(int l, int r, int it1, int it2, int low) {
if (l > r) return 1;
if (it1 > it2) return pow2[r - l];
if (it1 <= it2) {
long long s1 = 0, s2 = 0;
if (a[it1] >= a[it2]) {
if (a[it1] > low)
lol = 0;
else {
low = a[it1];
s1 = (do_c(it1 - l, r - l - a[it1] + 1));
int l0 = it1 + 1;
int r0 = it1 + a[it1] - 1;
int it10 = it1 + 1;
while ((!a[it10]) && (it10 < n)) it10++;
s1 = (s1 * doit(l0, r0, it10, it2, low)) % md;
}
}
if (a[it1] <= a[it2]) {
if (a[it2] > low)
lol = 0;
else {
low = a[it2];
s2 = do_c(r - it2, r - l - a[it2] + 1);
int r0 = it2 - 1;
int l0 = it2 - a[it2] + 1;
int it20 = it2 - 1;
while ((!a[it20]) && (it20 >= 0)) it20--;
s2 = (s2 * doit(l0, r0, it1, it20, low)) % md;
}
}
if ((a[it1] != 1) || (a[it2] != 1)) s1 = (s1 + s2) % md;
return s1;
}
}
int main() {
cin >> n;
do_fact();
int it1 = md, it2 = 0;
pow2[0] = 1;
for (int i = 0; i < n; i++) pow2[i + 1] = (pow2[i] << 1) % md;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i]) it2 = i;
if (a[i] && (it1 == md)) it1 = i;
}
ans = doit(0, n - 1, it1, it2, md);
ans = ans * lol;
cout << ans;
cin >> n;
return 0;
}
|
Now it's time of Olympiads. Vanya and Egor decided to make his own team to take part in a programming Olympiad. They've been best friends ever since primary school and hopefully, that can somehow help them in teamwork.
For each team Olympiad, Vanya takes his play cards with numbers. He takes only the cards containing numbers 1 and 0. The boys are very superstitious. They think that they can do well at the Olympiad if they begin with laying all the cards in a row so that:
* there wouldn't be a pair of any side-adjacent cards with zeroes in a row;
* there wouldn't be a group of three consecutive cards containing numbers one.
Today Vanya brought n cards with zeroes and m cards with numbers one. The number of cards was so much that the friends do not know how to put all those cards in the described way. Help them find the required arrangement of the cards or else tell the guys that it is impossible to arrange cards in such a way.
Input
The first line contains two integers: n (1 ≤ n ≤ 106) — the number of cards containing number 0; m (1 ≤ m ≤ 106) — the number of cards containing number 1.
Output
In a single line print the required sequence of zeroes and ones without any spaces. If such sequence is impossible to obtain, print -1.
Examples
Input
1 2
Output
101
Input
4 8
Output
110110110101
Input
4 10
Output
11011011011011
Input
1 5
Output
-1
|
n,m = map(int, raw_input().split())
resp = ''
num_1 = 0
num_0 = 0
if n - 1 == m:
resp = '0'
temp = '10'
resp += m * temp
n = 0
m = 0
while n != 0 or m != 0:
if n == m:
temp = '01'
resp += n * temp
n = 0
m = 0
break
else:
if m != 0 and num_1 != 2:
resp += '1'
m -= 1
num_1 += 1
num_0 = 0
elif n != 0 and num_0 == 0:
resp += '0'
num_1 = 0
num_0 += 1
n -= 1
else:
break
if n == 0 and m == 0:
print resp
else:
print -1
|
Iahub and Sorin are the best competitive programmers in their town. However, they can't both qualify to an important contest. The selection will be made with the help of a single problem. Blatnatalag, a friend of Iahub, managed to get hold of the problem before the contest. Because he wants to make sure Iahub will be the one qualified, he tells Iahub the following task.
You're given an (1-based) array a with n elements. Let's define function f(i, j) (1 ≤ i, j ≤ n) as (i - j)2 + g(i, j)2. Function g is calculated by the following pseudo-code:
int g(int i, int j) {
int sum = 0;
for (int k = min(i, j) + 1; k <= max(i, j); k = k + 1)
sum = sum + a[k];
return sum;
}
Find a value mini ≠ j f(i, j).
Probably by now Iahub already figured out the solution to this problem. Can you?
Input
The first line of input contains a single integer n (2 ≤ n ≤ 100000). Next line contains n integers a[1], a[2], ..., a[n] ( - 104 ≤ a[i] ≤ 104).
Output
Output a single integer — the value of mini ≠ j f(i, j).
Examples
Input
4
1 0 0 -1
Output
1
Input
2
1 -1
Output
2
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T inline sqr(T x) {
return x * x;
}
const long double pi = 3.1415926535897932384626433832795;
const long double eps = 1e-8;
const int N = 100500;
int a[N];
long long s[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) scanf("%d", &a[i]);
s[0] = a[0];
for (int i = 1; i <= (int)(n - 1); ++i) s[i] = s[i - 1] + a[i];
long long ans = sqr(*min_element(a + 1, a + n)) + 1;
for (int d = 1; d * d < ans; d++) {
if (clock() > CLOCKS_PER_SEC * 1.8) break;
for (int i = 0; i < (int)(n - d); ++i) {
ans = min(ans, sqr(s[i + d] - s[i]) + d * d);
}
}
cout << ans << endl;
return 0;
}
|
Being a programmer, you like arrays a lot. For your birthday, your friends have given you an array a consisting of n distinct integers.
Unfortunately, the size of a is too small. You want a bigger array! Your friends agree to give you a bigger array, but only if you are able to answer the following question correctly: is it possible to sort the array a (in increasing order) by reversing exactly one segment of a? See definitions of segment and reversing in the notes.
Input
The first line of the input contains an integer n (1 ≤ n ≤ 105) — the size of array a.
The second line contains n distinct space-separated integers: a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ 109).
Output
Print "yes" or "no" (without quotes), depending on the answer.
If your answer is "yes", then also print two space-separated integers denoting start and end (start must not be greater than end) indices of the segment to be reversed. If there are multiple ways of selecting these indices, print any of them.
Examples
Input
3
3 2 1
Output
yes
1 3
Input
4
2 1 3 4
Output
yes
1 2
Input
4
3 1 2 4
Output
no
Input
2
1 2
Output
yes
1 1
Note
Sample 1. You can reverse the entire array to get [1, 2, 3], which is sorted.
Sample 3. No segment can be reversed such that the array will be sorted.
Definitions
A segment [l, r] of array a is the sequence a[l], a[l + 1], ..., a[r].
If you have an array a of size n and you reverse its segment [l, r], the array will become:
a[1], a[2], ..., a[l - 2], a[l - 1], a[r], a[r - 1], ..., a[l + 1], a[l], a[r + 1], a[r + 2], ..., a[n - 1], a[n].
|
#include <bits/stdc++.h>
using namespace std;
int n, l, r, i, sl;
int a[1000000], b[1000000];
queue<int> que;
stack<int> tk;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b + 1, b + 1 + n);
int dd = 0;
for (int i = 1; i <= n; i++) {
if (dd == 1) {
que.push(a[i]);
tk.push(b[i]);
int kt = 0;
while (!que.empty() && !tk.empty() && que.front() == tk.top()) {
que.pop();
tk.pop();
kt = 1;
r = i;
}
if (kt == 1) {
if (!que.empty() || !tk.empty()) sl++;
dd = 0;
}
sl += kt;
} else if (a[i] != b[i] && dd == 0) {
que.push(a[i]);
tk.push(b[i]);
dd = 1;
l = i;
}
}
if (!que.empty() || !tk.empty() || sl > 1)
cout << "no";
else {
if (sl == 0) {
cout << "yes" << endl;
cout << 1 << " " << 1;
} else {
cout << "yes" << endl;
cout << l << " " << r;
}
}
return 0;
}
|
Our good friend Mole is trying to code a big message. He is typing on an unusual keyboard with characters arranged in following way:
qwertyuiop
asdfghjkl;
zxcvbnm,./
Unfortunately Mole is blind, so sometimes it is problem for him to put his hands accurately. He accidentally moved both his hands with one position to the left or to the right. That means that now he presses not a button he wants, but one neighboring button (left or right, as specified in input).
We have a sequence of characters he has typed and we want to find the original message.
Input
First line of the input contains one letter describing direction of shifting ('L' or 'R' respectively for left or right).
Second line contains a sequence of characters written by Mole. The size of this sequence will be no more than 100. Sequence contains only symbols that appear on Mole's keyboard. It doesn't contain spaces as there is no space on Mole's keyboard.
It is guaranteed that even though Mole hands are moved, he is still pressing buttons on keyboard and not hitting outside it.
Output
Print a line that contains the original message.
Examples
Input
R
s;;upimrrfod;pbr
Output
allyouneedislove
|
move=input()
ans=""
s=input()
keyboard=["qwertyuiop","asdfghjkl;","zxcvbnm,./"]
if move =="R":
for i in range(len(s)):
for j in range(len(keyboard)):
if s[i] in keyboard[j]:
ans+=keyboard[j][keyboard[j].index(s[i])-1]
elif move =="L":
for i in range(len(s)):
for j in range(len(keyboard)):
if s[i] in keyboard[j]:
ans+=keyboard[j][keyboard[j].index(s[i])+1]
print(ans)
|
Assume that sk(n) equals the sum of digits of number n in the k-based notation. For example, s2(5) = s2(1012) = 1 + 0 + 1 = 2, s3(14) = s3(1123) = 1 + 1 + 2 = 4.
The sequence of integers a0, ..., an - 1 is defined as <image>. Your task is to calculate the number of distinct subsequences of sequence a0, ..., an - 1. Calculate the answer modulo 109 + 7.
Sequence a1, ..., ak is called to be a subsequence of sequence b1, ..., bl, if there is a sequence of indices 1 ≤ i1 < ... < ik ≤ l, such that a1 = bi1, ..., ak = bik. In particular, an empty sequence (i.e. the sequence consisting of zero elements) is a subsequence of any sequence.
Input
The first line contains two space-separated numbers n and k (1 ≤ n ≤ 1018, 2 ≤ k ≤ 30).
Output
In a single line print the answer to the problem modulo 109 + 7.
Examples
Input
4 2
Output
11
Input
7 7
Output
128
Note
In the first sample the sequence ai looks as follows: (0, 1, 1, 0). All the possible subsequences are:
(), (0), (0, 0), (0, 1), (0, 1, 0), (0, 1, 1), (0, 1, 1, 0), (1), (1, 0), (1, 1), (1, 1, 0).
In the second sample the sequence ai looks as follows: (0, 1, 2, 3, 4, 5, 6). The subsequences of this sequence are exactly all increasing sequences formed from numbers from 0 to 6. It is easy to see that there are 27 = 128 such sequences.
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3e1 + 5;
const int LOG = 6e1 + 5;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
int d[LOG];
struct Matrix {
int n, m, M[maxN][maxN];
Matrix(int _n = 0, int _m = 0) {
n = _n;
m = _m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) M[i][j] = 0;
return;
}
int* operator[](int i) { return M[i]; }
Matrix operator*(const Matrix& A) {
Matrix B(n, A.m);
for (int i = 0; i < n; i++)
for (int k = 0; k < m; k++)
for (int j = 0; j < A.m; j++)
B[i][j] = (0ll + B[i][j] + 1ll * M[i][k] * A.M[k][j] % MOD) % MOD;
return B;
}
void print() {
for (int i = 0; i < n; i++, printf("\n"))
for (int j = 0; j < m; j++) printf("%d ", M[i][j]);
printf("\n");
return;
}
} K[LOG];
int main() {
time_t START = clock();
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
int k;
scanf("%lld%d", &n, &k);
for (int i = 0; i < LOG; i++) K[i] = Matrix(k + 1, k + 1);
for (int i = 1; i < LOG; i++)
for (int j = 0; j <= k; j++) K[i][j][j] = 1;
Matrix S(k + 1, k + 1), T(k + 1, k + 1);
Matrix R(k + 1, k + 1), t(k + 1, k + 1);
for (int i = 0; i < k; i++) {
S[i][(k + i - 1) % k] = 1;
T[(k + i - 1) % k][i] = 1;
}
S[k][k] = T[k][k] = 1;
for (int i = 0; i <= k; i++) K[0][0][i] = K[0][i][i] = 1;
long long m = n;
int cnt = 0;
for (int i = 1; m >= k; m /= k, i++) {
d[cnt++] = m % k;
for (int j = 0; j <= k; j++) K[i][j][j] = 1;
t = K[i - 1];
for (int j = 0; j < k; j++) {
K[i] = t * K[i];
t = (S * t) * T;
}
}
d[cnt] = m;
for (int i = 0; i <= k; i++) R[i][i] = 1;
int sum = 0;
for (cnt; cnt > -1; cnt--) {
t = K[cnt];
for (int i = 0; i < sum; i++) t = (S * t) * T;
for (int i = 0; i < d[cnt]; i++) {
R = t * R;
t = (S * t) * T;
}
sum = (sum + d[cnt]) % k;
}
int ans = 0;
for (int i = 0; i <= k; i++) ans = (ans + R[i][k]) % MOD;
printf("%d\n", ans);
time_t FINISH = clock();
cerr << "Execution time: "
<< (long double)(FINISH - START) / CLOCKS_PER_SEC * 1000.0
<< " milliseconds.\n";
return 0;
}
|
Vasya became interested in bioinformatics. He's going to write an article about similar cyclic DNA sequences, so he invented a new method for determining the similarity of cyclic sequences.
Let's assume that strings s and t have the same length n, then the function h(s, t) is defined as the number of positions in which the respective symbols of s and t are the same. Function h(s, t) can be used to define the function of Vasya distance ρ(s, t):
<image> where <image> is obtained from string s, by applying left circular shift i times. For example, ρ("AGC", "CGT") = h("AGC", "CGT") + h("AGC", "GTC") + h("AGC", "TCG") + h("GCA", "CGT") + h("GCA", "GTC") + h("GCA", "TCG") + h("CAG", "CGT") + h("CAG", "GTC") + h("CAG", "TCG") = 1 + 1 + 0 + 0 + 1 + 1 + 1 + 0 + 1 = 6
Vasya found a string s of length n on the Internet. Now he wants to count how many strings t there are such that the Vasya distance from the string s attains maximum possible value. Formally speaking, t must satisfy the equation: <image>.
Vasya could not try all possible strings to find an answer, so he needs your help. As the answer may be very large, count the number of such strings modulo 109 + 7.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 105).
The second line of the input contains a single string of length n, consisting of characters "ACGT".
Output
Print a single number — the answer modulo 109 + 7.
Examples
Input
1
C
Output
1
Input
2
AG
Output
4
Input
3
TTT
Output
1
Note
Please note that if for two distinct strings t1 and t2 values ρ(s, t1) и ρ(s, t2) are maximum among all possible t, then both strings must be taken into account in the answer even if one of them can be obtained by a circular shift of another one.
In the first sample, there is ρ("C", "C") = 1, for the remaining strings t of length 1 the value of ρ(s, t) is 0.
In the second sample, ρ("AG", "AG") = ρ("AG", "GA") = ρ("AG", "AA") = ρ("AG", "GG") = 4.
In the third sample, ρ("TTT", "TTT") = 27
|
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main{
final static int MOD = 1000000007;
public static void main(String[] args){
Scan scan = new Scan();
int n = scan.nextInt();
String s = scan.next();
int[] counter = new int[4];
for(int i=0;i<n;i++){
switch(s.charAt(i)){
case 'A':
counter[0]++;
break;
case 'C':
counter[1]++;
break;
case 'G':
counter[2]++;
break;
case 'T':
counter[3]++;
break;
}
}
Arrays.sort(counter);
if(counter[0] == counter[3]){
System.out.println(powermod(4, n));
}else if(counter[1] == counter[3]){
System.out.println(powermod(3, n));
}else if(counter[2] == counter[3]){
System.out.println(powermod(2, n));
}else{
System.out.println(powermod(1, n));
}
}
static int powermod(int base, int n){
long result = 1, now = base;
while(n > 0){
if((n&1) == 1) result = result*now % MOD;
now = now*now % MOD;
n >>= 1;
}
return (int)result;
}
}
class Scan{
BufferedReader buffer;
StringTokenizer tok;
Scan(){
buffer = new BufferedReader(new InputStreamReader(System.in));
}
boolean hasNext(){
while(tok==null || !tok.hasMoreElements()){
try{
tok = new StringTokenizer(buffer.readLine());
}catch(Exception e){
return false;
}
}
return true;
}
String next(){
if(hasNext()) return tok.nextToken();
return null;
}
int nextInt(){
return Integer.parseInt(next());
}
}
|
Mike has a frog and a flower. His frog is named Xaniar and his flower is named Abol. Initially(at time 0), height of Xaniar is h1 and height of Abol is h2. Each second, Mike waters Abol and Xaniar.
<image>
So, if height of Xaniar is h1 and height of Abol is h2, after one second height of Xaniar will become <image> and height of Abol will become <image> where x1, y1, x2 and y2 are some integer numbers and <image> denotes the remainder of a modulo b.
Mike is a competitive programmer fan. He wants to know the minimum time it takes until height of Xania is a1 and height of Abol is a2.
Mike has asked you for your help. Calculate the minimum time or say it will never happen.
Input
The first line of input contains integer m (2 ≤ m ≤ 106).
The second line of input contains integers h1 and a1 (0 ≤ h1, a1 < m).
The third line of input contains integers x1 and y1 (0 ≤ x1, y1 < m).
The fourth line of input contains integers h2 and a2 (0 ≤ h2, a2 < m).
The fifth line of input contains integers x2 and y2 (0 ≤ x2, y2 < m).
It is guaranteed that h1 ≠ a1 and h2 ≠ a2.
Output
Print the minimum number of seconds until Xaniar reaches height a1 and Abol reaches height a2 or print -1 otherwise.
Examples
Input
5
4 2
1 1
0 1
2 3
Output
3
Input
1023
1 2
1 0
1 2
1 1
Output
-1
Note
In the first sample, heights sequences are following:
Xaniar: <image>
Abol: <image>
|
#include <bits/stdc++.h>
using namespace std;
void FastIO() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
FastIO();
long long int m;
cin >> m;
long long int h[2], a[2], x[2], y[2];
for (int i = 0; i < (int)2; i++) {
cin >> h[i] >> a[i] >> x[i] >> y[i];
}
long long int steps1 = 0;
for (int i = (int)1; i <= (int)m; i++) {
h[0] = (x[0] * h[0] + y[0]) % m;
if (h[0] == a[0]) {
steps1 = i;
break;
}
}
if (!steps1) {
cout << "-1" << '\n';
return 0;
}
long long int steps2 = 0;
for (int i = (int)1; i <= (int)m; i++) {
h[0] = (x[0] * h[0] + y[0]) % m;
if (h[0] == a[0]) {
steps2 = i;
break;
}
}
long long int steps3 = 0;
for (int i = (int)1; i <= (int)m; i++) {
h[1] = (x[1] * h[1] + y[1]) % m;
if (h[1] == a[1]) {
steps3 = i;
break;
}
}
if (!steps3) {
cout << "-1" << '\n';
return 0;
}
long long int steps4 = 0;
for (int i = (int)1; i <= (int)m; i++) {
h[1] = (x[1] * h[1] + y[1]) % m;
if (h[1] == a[1]) {
steps4 = i;
break;
}
}
long long int ans = 1e18;
if (steps2 && steps4) {
for (int i = 0; i < (int)1e7; i++) {
if ((steps1 + i * steps2 - steps3) % steps4 == 0 &&
(steps1 + i * steps2 - steps3) >= 0) {
ans = min(ans, steps1 + i * steps2);
break;
}
}
} else if (steps2) {
for (int i = 0; i < (int)1e7; i++) {
if ((steps1 + i * steps2 == steps3)) {
ans = min(ans, steps1 + i * steps2);
break;
}
}
} else if (steps4) {
for (int i = 0; i < (int)1e7; i++) {
if ((steps3 + i * steps4 == steps1)) {
ans = min(ans, steps3 + i * steps4);
break;
}
}
} else {
ans = min(ans, steps1 * (steps1 == steps3));
}
if (ans == 1e18) ans = -1;
cout << ans << '\n';
return 0;
}
|
Limak is a little bear who learns to draw. People usually start with houses, fences and flowers but why would bears do it? Limak lives in the forest and he decides to draw a tree.
Recall that tree is a connected graph consisting of n vertices and n - 1 edges.
Limak chose a tree with n vertices. He has infinite strip of paper with two parallel rows of dots. Little bear wants to assign vertices of a tree to some n distinct dots on a paper so that edges would intersect only at their endpoints — drawn tree must be planar. Below you can see one of correct drawings for the first sample test.
<image>
Is it possible for Limak to draw chosen tree?
Input
The first line contains single integer n (1 ≤ n ≤ 105).
Next n - 1 lines contain description of a tree. i-th of them contains two space-separated integers ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi) denoting an edge between vertices ai and bi. It's guaranteed that given description forms a tree.
Output
Print "Yes" (without the quotes) if Limak can draw chosen tree. Otherwise, print "No" (without the quotes).
Examples
Input
8
1 2
1 3
1 6
6 4
6 7
6 5
7 8
Output
Yes
Input
13
1 2
1 3
1 4
2 5
2 6
2 7
3 8
3 9
3 10
4 11
4 12
4 13
Output
No
|
import java.io.BufferedInputStream;
import java.util.*;
public class EDrawing {
public static void main(String[] args) {
final Scanner scanner = new Scanner(new BufferedInputStream(System.in));
int N = scanner.nextInt();
final Graph graph = new Graph(N);
for (int i = 0; i < N - 1; i++) {
graph.addEdge(scanner.nextInt() - 1, scanner.nextInt() - 1);
}
boolean isGood = graph.solve();
System.out.println(isGood ? "Yes" : "No");
}
}
class Graph {
static int CLEAN = 0;
static int COMPRESSED = 1; // deleted node due to compression
static int YVERTICE = 2; // a node with 1 or 2 COMPRESSED nodes and 1 edge to a CLEAN node
int N;
List<List<Integer>> neighbors;
int[] status;
public Graph(int n) {
N = n;
neighbors = new ArrayList<>(N);
for (int i = 0; i < N; i++)
neighbors.add(i, new LinkedList<>());
status = new int[N];
}
public void addEdge(int x, int y) {
neighbors.get(x).add(y);
neighbors.get(y).add(x);
}
public boolean solve() {
Arrays.fill(status, CLEAN);
// compress long nodes first
for (int i = 0; i < N; i++) {
if (status[i] == CLEAN && neighbors.get(i).size() == 1) {
compress(i);
}
}
// mark Y-VERTICES
for (int i = 0; i < N; i++) {
if (status[i] == CLEAN && (neighbors.get(i).size() == 2 || neighbors.get(i).size() == 3)) {
int clean = 0;
boolean hasYAsNeighbor = false;
for (int next : neighbors.get(i)) {
if (status[next] == CLEAN) {
clean++;
} else if (status[next] == YVERTICE) {
hasYAsNeighbor = true;
break;
}
}
if (clean == 1 && !hasYAsNeighbor) status[i] = YVERTICE;
}
}
for (int i = 0; i < N; i++) {
if (status[i] == CLEAN) {
int clean = 0;
for (int next : neighbors.get(i)) {
if (status[next] == CLEAN)
clean++;
}
if (clean > 2) return false;
}
}
return true;
}
public void compress(int cur) {
status[cur] = COMPRESSED;
for (int next : neighbors.get(cur)) {
if (status[next] == CLEAN && neighbors.get(next).size() == 2)
compress(next);
}
}
}
|
Wilbur is playing with a set of n points on the coordinate plane. All points have non-negative integer coordinates. Moreover, if some point (x, y) belongs to the set, then all points (x', y'), such that 0 ≤ x' ≤ x and 0 ≤ y' ≤ y also belong to this set.
Now Wilbur wants to number the points in the set he has, that is assign them distinct integer numbers from 1 to n. In order to make the numbering aesthetically pleasing, Wilbur imposes the condition that if some point (x, y) gets number i, then all (x',y') from the set, such that x' ≥ x and y' ≥ y must be assigned a number not less than i. For example, for a set of four points (0, 0), (0, 1), (1, 0) and (1, 1), there are two aesthetically pleasing numberings. One is 1, 2, 3, 4 and another one is 1, 3, 2, 4.
Wilbur's friend comes along and challenges Wilbur. For any point he defines it's special value as s(x, y) = y - x. Now he gives Wilbur some w1, w2,..., wn, and asks him to find an aesthetically pleasing numbering of the points in the set, such that the point that gets number i has it's special value equal to wi, that is s(xi, yi) = yi - xi = wi.
Now Wilbur asks you to help him with this challenge.
Input
The first line of the input consists of a single integer n (1 ≤ n ≤ 100 000) — the number of points in the set Wilbur is playing with.
Next follow n lines with points descriptions. Each line contains two integers x and y (0 ≤ x, y ≤ 100 000), that give one point in Wilbur's set. It's guaranteed that all points are distinct. Also, it is guaranteed that if some point (x, y) is present in the input, then all points (x', y'), such that 0 ≤ x' ≤ x and 0 ≤ y' ≤ y, are also present in the input.
The last line of the input contains n integers. The i-th of them is wi ( - 100 000 ≤ wi ≤ 100 000) — the required special value of the point that gets number i in any aesthetically pleasing numbering.
Output
If there exists an aesthetically pleasant numbering of points in the set, such that s(xi, yi) = yi - xi = wi, then print "YES" on the first line of the output. Otherwise, print "NO".
If a solution exists, proceed output with n lines. On the i-th of these lines print the point of the set that gets number i. If there are multiple solutions, print any of them.
Examples
Input
5
2 0
0 0
1 0
1 1
0 1
0 -1 -2 1 0
Output
YES
0 0
1 0
2 0
0 1
1 1
Input
3
1 0
0 0
2 0
0 1 2
Output
NO
Note
In the first sample, point (2, 0) gets number 3, point (0, 0) gets number one, point (1, 0) gets number 2, point (1, 1) gets number 5 and point (0, 1) gets number 4. One can easily check that this numbering is aesthetically pleasing and yi - xi = wi.
In the second sample, the special values of the points in the set are 0, - 1, and - 2 while the sequence that the friend gives to Wilbur is 0, 1, 2. Therefore, the answer does not exist.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
const int MAXNUM = 100000;
int n;
int max_x[MAXNUM + 1];
int max_y;
int w[MAXN];
int res[MAXN][2];
int lookup(int t) {
int p = 0, q = max_y;
while (p < q) {
int y = (p + q) / 2;
if (y - max_x[y] < t)
p = y + 1;
else
q = y;
}
if (p > q) return -1;
if (p - max_x[p] != t) return -1;
if (p < max_y && max_x[p] == max_x[p + 1]) return -1;
return p;
}
int main() {
for (int i = 0; i <= MAXNUM; i++) max_x[i] = -1;
max_y = -1;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (x > max_x[y]) max_x[y] = x;
if (y > max_y) max_y = y;
}
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = n - 1; i >= 0; i--) {
int y = lookup(w[i]);
if (y == -1) {
cout << "NO" << endl;
return 0;
}
res[i][0] = max_x[y]--;
res[i][1] = y;
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << res[i][0] << " " << res[i][1] << endl;
return 0;
}
|
Bob has a favorite number k and ai of length n. Now he asks you to answer m queries. Each query is given by a pair li and ri and asks you to count the number of pairs of integers i and j, such that l ≤ i ≤ j ≤ r and the xor of the numbers ai, ai + 1, ..., aj is equal to k.
Input
The first line of the input contains integers n, m and k (1 ≤ n, m ≤ 100 000, 0 ≤ k ≤ 1 000 000) — the length of the array, the number of queries and Bob's favorite number respectively.
The second line contains n integers ai (0 ≤ ai ≤ 1 000 000) — Bob's array.
Then m lines follow. The i-th line contains integers li and ri (1 ≤ li ≤ ri ≤ n) — the parameters of the i-th query.
Output
Print m lines, answer the queries in the order they appear in the input.
Examples
Input
6 2 3
1 2 1 1 0 3
1 6
3 5
Output
7
0
Input
5 3 1
1 1 1 1 1
1 5
2 4
1 3
Output
9
4
4
Note
In the first sample the suitable pairs of i and j for the first query are: (1, 2), (1, 4), (1, 5), (2, 3), (3, 6), (5, 6), (6, 6). Not a single of these pairs is suitable for the second query.
In the second sample xor equals 1 for all subarrays of an odd length.
|
// package codeforces.cr340.div2;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.InputMismatchException;
/**
* Created by hama_du on 2016/02/16.
*/
public class Main {
public static void main(String[] args) {
InputReader in = new InputReader(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt();
int m = in.nextInt();
int k = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n ; i++) {
a[i] = in.nextInt();
}
int[][] lr = new int[m][2];
for (int i = 0; i < m ; i++) {
lr[i][0] = in.nextInt()-1;
lr[i][1] = in.nextInt();
}
long[] mo = new long[m]; // sqrtSort(lr, 100000);
for (int i = 0; i < m ; i++) {
mo[i] |= ((long)lr[i][0]/320L)<<50;
mo[i] |= (((lr[i][0]/320L)&1) == 0 ? (long)lr[i][1] : (long)(1<<25)-1-lr[i][1])<<25;
mo[i] |= i;
}
// (long)q[i][0]/S<<50|(long)((q[i][0]/S&1)==0?q[i][1]:(1<<25)-1-q[i][1])<<25|i;
Arrays.sort(mo);
int[] imos = new int[n+1];
for (int i = 0; i < n ; i++) {
imos[i+1] = imos[i] ^ a[i];
}
long[] ans = new long[m];
int L = 0;
int R = 0;
long[] table = new long[4000000];
table[0] = 1;
long val = 0;
for (int qi = 0 ; qi < m ; qi++) {
int i = (int)(mo[qi] & ((1<<25) - 1));
int toL = lr[i][0];
int toR = lr[i][1];
while (toR > R) {
val += table[k ^ imos[R+1]];
table[imos[R+1]]++;
R++;
}
while (toL < L) {
val += table[k ^ imos[L-1]];
table[imos[L-1]]++;
L--;
}
while (toR < R) {
R--;
table[imos[R+1]]--;
val -= table[k ^ imos[R+1]];
}
while (toL > L) {
L++;
table[imos[L-1]]--;
val -= table[k ^ imos[L-1]];
}
ans[i] = val;
}
for (int i = 0 ; i < m ; i++) {
out.println(ans[i]);
}
out.flush();
}
public static long[] sqrtSort(int[][] q, int n)
{
int m = q.length;
long[] pack = new long[m];
int S = (int)Math.sqrt(n);
for(int i = 0;i < m;i++){
pack[i] = (long)q[i][0]/S<<50|(long)((q[i][0]/S&1)==0?q[i][1]:(1<<25)-1-q[i][1])<<25|i;
}
Arrays.sort(pack);
return pack;
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
private int next() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public char nextChar() {
int c = next();
while (isSpaceChar(c))
c = next();
if ('a' <= c && c <= 'z') {
return (char) c;
}
if ('A' <= c && c <= 'Z') {
return (char) c;
}
throw new InputMismatchException();
}
public String nextToken() {
int c = next();
while (isSpaceChar(c))
c = next();
StringBuilder res = new StringBuilder();
do {
res.append((char) c);
c = next();
} while (!isSpaceChar(c));
return res.toString();
}
public int nextInt() {
int c = next();
while (isSpaceChar(c))
c = next();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = next();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c-'0';
c = next();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = next();
while (isSpaceChar(c))
c = next();
long sgn = 1;
if (c == '-') {
sgn = -1;
c = next();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c-'0';
c = next();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
static void debug(Object... o) {
System.err.println(Arrays.deepToString(o));
}
}
|
Berland scientists face a very important task - given the parts of short DNA fragments, restore the dinosaur DNA! The genome of a berland dinosaur has noting in common with the genome that we've used to: it can have 26 distinct nucleotide types, a nucleotide of each type can occur at most once. If we assign distinct English letters to all nucleotides, then the genome of a Berland dinosaur will represent a non-empty string consisting of small English letters, such that each letter occurs in it at most once.
Scientists have n genome fragments that are represented as substrings (non-empty sequences of consecutive nucleotides) of the sought genome.
You face the following problem: help scientists restore the dinosaur genome. It is guaranteed that the input is not contradictory and at least one suitable line always exists. When the scientists found out that you are a strong programmer, they asked you in addition to choose the one with the minimum length. If there are multiple such strings, choose any string.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 100) — the number of genome fragments.
Each of the next lines contains one descriptions of a fragment. Each fragment is a non-empty string consisting of distinct small letters of the English alphabet. It is not guaranteed that the given fragments are distinct. Fragments could arbitrarily overlap and one fragment could be a substring of another one.
It is guaranteed that there is such string of distinct letters that contains all the given fragments as substrings.
Output
In the single line of the output print the genome of the minimum length that contains all the given parts. All the nucleotides in the genome must be distinct. If there are multiple suitable strings, print the string of the minimum length. If there also are multiple suitable strings, you can print any of them.
Examples
Input
3
bcd
ab
cdef
Output
abcdef
Input
4
x
y
z
w
Output
xyzw
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 5;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const long long LLINF = (long long)1e18;
int n;
bool a[26][26];
bool was[26];
void dfs(int x) {
cout << char(97 + x);
for (int to = 0; to < 26; ++to) {
if (a[x][to]) {
dfs(to);
}
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string t;
cin >> t;
for (int j = 0; j < t.size(); ++j) {
was[t[j] - 'a'] = true;
}
for (int j = 1; j < t.size(); ++j) {
a[t[j - 1] - 'a'][t[j] - 'a'] = true;
}
}
for (int i = 0; i < 26; ++i) {
if (!was[i]) continue;
bool ok = true;
for (int j = 0; j < 26; ++j) {
if (a[j][i] == true) ok = false;
}
if (ok) {
dfs(i);
}
}
return 0;
}
|
If an integer a is divisible by another integer b, then b is called the divisor of a.
For example: 12 has positive 6 divisors. They are 1, 2, 3, 4, 6 and 12.
Let’s define a function D(n) — number of integers between 1 and n (inclusive) which has exactly four positive divisors.
Between 1 and 10 only the integers 6, 8 and 10 has exactly four positive divisors. So, D(10) = 3.
You are given an integer n. You have to calculate D(n).
Input
The only line contains integer n (1 ≤ n ≤ 1011) — the parameter from the problem statement.
Output
Print the only integer c — the number of integers between 1 and n with exactly four divisors.
Examples
Input
10
Output
3
Input
20
Output
5
|
#include <bits/stdc++.h>
using namespace std;
int Lower[1000000 + 1], Higher[1000000 + 1];
char Used[1000000 + 1];
long long SumNat(long long n) {
long long p = n, q = n + 1;
if (p % 2)
q /= 2;
else
p /= 2;
return (p) * (q);
}
long long PrimePi(long long n) {
long long v = sqrt(n + 1e-9), p, temp, q, j, end, i, d, t;
for (int i = 0; i <= 1000000; i++) Used[i] = 0;
Higher[1] = n - 1;
for (p = 2; p <= v; p++) {
Lower[p] = p - 1;
Higher[p] = (n / p) - 1;
}
for (p = 2; p <= v; p++) {
if (Lower[p] == Lower[p - 1]) continue;
temp = Lower[p - 1];
q = p * p;
Higher[1] -= Higher[p] - temp;
j = 1 + (p & 1);
end = (v <= n / q) ? v : n / q;
for (i = p + j; i <= 1 + end; i += j) {
if (Used[i]) continue;
d = i * p;
if (d <= v)
Higher[i] -= Higher[d] - temp;
else {
t = n / d;
Higher[i] -= Lower[t] - temp;
}
}
if (q <= v)
for (i = q; i <= end; i += p * j) Used[i] = 1;
for (i = v; i >= q; i--) {
t = i / p;
Lower[i] -= Lower[t] - temp;
}
}
return Higher[1];
}
bool prime[10000000 + 1];
long long piii[10000000 + 1];
long long Prim(long long n) {
if (n <= 10000000) return piii[n];
return PrimePi(n);
}
int main() {
long long n, i, j;
long long answer;
for (i = 2; i * i <= 10000000; i++)
if (!prime[i])
for (j = i * i; j <= 10000000; j += i) prime[j] = true;
for (i = 2; i <= 10000000; i++) {
piii[i] = piii[i - 1];
if (!prime[i]) piii[i]++;
}
cin >> n;
for (i = 1;; i++) {
if (i * i * i > n) break;
}
answer = Prim(i - 1);
for (i = 2; i < (n / i); i++)
if (!prime[i]) answer += (Prim(n / i) - Prim(i));
cout << answer;
return 0;
}
|
Recently Petya has become keen on physics. Anna V., his teacher noticed Petya's interest and gave him a fascinating physical puzzle — a half-decay tree.
A half-decay tree is a complete binary tree with the height h. The height of a tree is the length of the path (in edges) from the root to a leaf in the tree. While studying the tree Petya can add electrons to vertices or induce random decay with synchrophasotron. Random decay is a process during which the edges of some path from the root to the random leaf of the tree are deleted. All the leaves are equiprobable. As the half-decay tree is the school property, Petya will return back the deleted edges into the tree after each decay.
After being desintegrated, the tree decomposes into connected components. Charge of each component is the total quantity of electrons placed in vertices of the component. Potential of desintegerated tree is the maximum from the charges of its connected components. Each time before inducing random decay Petya is curious about the mathematical expectation of potential of the tree after being desintegrated.
Input
First line will contain two integers h and q (1 ≤ h ≤ 30, 1 ≤ q ≤ 105). Next q lines will contain a query of one of two types:
* add v e
Petya adds e electrons to vertex number v (1 ≤ v ≤ 2h + 1 - 1, 0 ≤ e ≤ 104). v and e are integers.
The vertices of the tree are numbered in the following way: the root is numbered with 1, the children of the vertex with number x are numbered with 2x and 2x + 1.
* decay
Petya induces tree decay.
Output
For each query decay solution you should output the mathematical expectation of potential of the tree after being desintegrated. The absolute or relative error in the answer should not exceed 10 - 4.
Examples
Input
1 4
add 1 3
add 2 10
add 3 11
decay
Output
13.50000000
|
#include <bits/stdc++.h>
using namespace std;
namespace output {
void __(short x) { cout << x; }
void __(unsigned x) { cout << x; }
void __(int x) { cout << x; }
void __(long long x) { cout << x; }
void __(unsigned long long x) { cout << x; }
void __(double x) { cout << x; }
void __(long double x) { cout << x; }
void __(char x) { cout << x; }
void __(const char* x) { cout << x; }
void __(const string& x) { cout << x; }
void __(bool x) { cout << (x ? "true" : "false"); }
template <class S, class T>
void __(const pair<S, T>& x) {
__(1 ? "(" : ""), __(x.first), __(1 ? ", " : " "), __(x.second),
__(1 ? ")" : "");
}
template <class T>
void __(const vector<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class T>
void __(const set<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class T>
void __(const multiset<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class S, class T>
void __(const map<S, T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
void pr() { cout << "\n"; }
template <class S, class... T>
void pr(const S& a, const T&... b) {
__(a);
if (sizeof...(b)) __(' ');
pr(b...);
}
} // namespace output
using namespace output;
const int MN = 33;
int h, q, i, x, y;
string s;
map<int, int> sm, val;
int main() {
scanf("%d%d", &h, &q);
for (; q; q--) {
cin >> s;
if (s == "add") {
scanf("%d%d", &x, &y);
val[x] += y;
while (x) {
sm[x] += y;
x >>= 1;
}
} else {
x = 1;
int mx = 0;
double prob = 1, ans = 0;
for (i = 0; i < h; i++) {
int lsum = val[x] + sm[x << 1], rsum = val[x] + sm[(x << 1) | 1];
if (lsum > rsum) {
ans += prob / 2.0 * max(mx, lsum);
mx = max(mx, rsum);
x = (x << 1);
} else {
ans += prob / 2.0 * max(mx, rsum);
mx = max(mx, lsum);
x = (x << 1) | 1;
}
prob /= 2;
}
ans += prob * max(mx, val[x]);
printf("%.6lf\n", ans);
}
}
return 0;
}
|
Memory is performing a walk on the two-dimensional plane, starting at the origin. He is given a string s with his directions for motion:
* An 'L' indicates he should move one unit left.
* An 'R' indicates he should move one unit right.
* A 'U' indicates he should move one unit up.
* A 'D' indicates he should move one unit down.
But now Memory wants to end at the origin. To do this, he has a special trident. This trident can replace any character in s with any of 'L', 'R', 'U', or 'D'. However, because he doesn't want to wear out the trident, he wants to make the minimum number of edits possible. Please tell Memory what is the minimum number of changes he needs to make to produce a string that, when walked, will end at the origin, or if there is no such string.
Input
The first and only line contains the string s (1 ≤ |s| ≤ 100 000) — the instructions Memory is given.
Output
If there is a string satisfying the conditions, output a single integer — the minimum number of edits required. In case it's not possible to change the sequence in such a way that it will bring Memory to to the origin, output -1.
Examples
Input
RRU
Output
-1
Input
UDUR
Output
1
Input
RUUR
Output
2
Note
In the first sample test, Memory is told to walk right, then right, then up. It is easy to see that it is impossible to edit these instructions to form a valid walk.
In the second sample test, Memory is told to walk up, then down, then up, then right. One possible solution is to change s to "LDUR". This string uses 1 edit, which is the minimum possible. It also ends at the origin.
|
s = input()
ud = lr = 0
for ch in s:
if(ch=='R'):
lr = lr+1
if(ch=='L'):
lr = lr-1
if(ch=='U'):
ud = ud+1
if(ch=='D'):
ud = ud-1
if((abs(lr) + abs(ud))%2==1):
print(-1)
else:
print(int((abs(lr) + abs(ud))/2))
|
One day, the Grasshopper was jumping on the lawn and found a piece of paper with a string. Grasshopper became interested what is the minimum jump ability he should have in order to be able to reach the far end of the string, jumping only on vowels of the English alphabet. Jump ability is the maximum possible length of his jump.
Formally, consider that at the begginning the Grasshopper is located directly in front of the leftmost character of the string. His goal is to reach the position right after the rightmost character of the string. In one jump the Grasshopper could jump to the right any distance from 1 to the value of his jump ability.
<image> The picture corresponds to the first example.
The following letters are vowels: 'A', 'E', 'I', 'O', 'U' and 'Y'.
Input
The first line contains non-empty string consisting of capital English letters. It is guaranteed that the length of the string does not exceed 100.
Output
Print single integer a — the minimum jump ability of the Grasshopper (in the number of symbols) that is needed to overcome the given string, jumping only on vowels.
Examples
Input
ABABBBACFEYUKOTT
Output
4
Input
AAA
Output
1
|
def solve(a):
l = [0]
li = []
j = 0
for i in range(len(a)):
if a[i] == "A" or a[i] == "E" or a[i] == "I" or a[i] == "O" or a[i] == "U" or a[i] == "Y":
l.append(i + 1)
j += 1
li.append(l[j] - l[j-1])
l.append(i + 1)
j += 1
li.append(l[j] - l[j-1] + 1)
li.sort()
print(li[-1])
solve(input())
|
Bash has set out on a journey to become the greatest Pokemon master. To get his first Pokemon, he went to Professor Zulu's Lab. Since Bash is Professor Zulu's favourite student, Zulu allows him to take as many Pokemon from his lab as he pleases.
But Zulu warns him that a group of k > 1 Pokemon with strengths {s1, s2, s3, ..., sk} tend to fight among each other if gcd(s1, s2, s3, ..., sk) = 1 (see notes for gcd definition).
Bash, being smart, does not want his Pokemon to fight among each other. However, he also wants to maximize the number of Pokemon he takes from the lab. Can you help Bash find out the maximum number of Pokemon he can take?
Note: A Pokemon cannot fight with itself.
Input
The input consists of two lines.
The first line contains an integer n (1 ≤ n ≤ 105), the number of Pokemon in the lab.
The next line contains n space separated integers, where the i-th of them denotes si (1 ≤ si ≤ 105), the strength of the i-th Pokemon.
Output
Print single integer — the maximum number of Pokemons Bash can take.
Examples
Input
3
2 3 4
Output
2
Input
5
2 3 4 6 7
Output
3
Note
gcd (greatest common divisor) of positive integers set {a1, a2, ..., an} is the maximum positive integer that divides all the integers {a1, a2, ..., an}.
In the first sample, we can take Pokemons with strengths {2, 4} since gcd(2, 4) = 2.
In the second sample, we can take Pokemons with strengths {2, 4, 6}, and there is no larger group with gcd ≠ 1.
|
import static java.lang.System.out;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] s = new int[n];
int m = 0;
for (int i=0;i<n;i++)
{
s[i] = sc.nextInt();
m = Math.max(m, s[i]);
}
Arrays.sort(s);
int ans = 1;
int len = 1;
for (int i=1;i<n;i++)
{
if (s[i]==s[i-1] && s[i]!=1){
len++;
}else{
ans = Math.max(ans, len);
len=1;
}
}
ans = Math.max(ans, len);
for (int i=2;i*i<=m;i++)
{
int c1 = 0;
int c2 = 0;
int j = m/i;
for (int x : s)
{
if (x%i==0) c1++;
if (j>0 && x%j==0) c2++;
}
ans = Math.max(ans, Math.max(c1, c2));
}
out.println(ans);
sc.close();
}
}
|
Peter decided to lay a parquet in the room of size n × m, the parquet consists of tiles of size 1 × 2. When the workers laid the parquet, it became clear that the tiles pattern looks not like Peter likes, and workers will have to re-lay it.
The workers decided that removing entire parquet and then laying it again is very difficult task, so they decided to make such an operation every hour: remove two tiles, which form a 2 × 2 square, rotate them 90 degrees and put them back on the same place.
<image>
They have no idea how to obtain the desired configuration using these operations, and whether it is possible at all.
Help Peter to make a plan for the workers or tell that it is impossible. The plan should contain at most 100 000 commands.
Input
The first line contains integer n and m, size of the room (1 ≤ n, m ≤ 50). At least one of them is even number.
The following n lines contain m characters each, the description of the current configuration of the parquet tiles. Each character represents the position of the half-tile. Characters 'L', 'R', 'U' and 'D' correspond to the left, right, upper and lower halves, respectively.
The following n lines contain m characters each, describing the desired configuration in the same format.
Output
In the first line output integer k, the number of operations. In the next k lines output description of operations. The operation is specified by coordinates (row and column) of the left upper half-tile on which the operation is performed.
If there is no solution, output -1 in the first line.
Examples
Input
2 3
ULR
DLR
LRU
LRD
Output
2
1 2
1 1
Input
4 3
ULR
DLR
LRU
LRD
ULR
DUU
UDD
DLR
Output
3
3 1
3 2
2 2
Note
In the first sample test first operation is to rotate two rightmost tiles, after this all tiles lie vertically. Second operation is to rotate two leftmost tiles, after this we will get desired configuration.
<image>
|
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C &a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C &a4, C b4) {
a4 = max(a4, b4);
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const long long MAX = 51;
string t[MAX];
long long n, m;
vector<pair<long long, long long> > licz(long long x) {
long long bil = 0;
for (long long i = (0); i <= ((long long)(n)-1); i++) {
cin >> t[i];
for (long long j = (0); j <= ((long long)(m)-1); j++) {
if (t[i][j] == 'U') bil++;
if (t[i][j] == 'L') bil--;
}
}
vector<pair<long long, long long> > res;
bool co = 0;
while (bil != x) {
if (co) {
for (long long i = (0); i <= ((long long)(n - 1) - 1); i++)
for (long long j = (0); j <= ((long long)(m - 1) - 1); j++) {
if (t[i][j] == 'L' && t[i][j + 1] == 'R' && t[i + 1][j] == 'L' &&
t[i + 1][j + 1] == 'R') {
t[i][j] = t[i][j + 1] = 'U';
t[i + 1][j] = t[i + 1][j + 1] = 'D';
bil += 4;
res.push_back({i, j});
}
}
} else {
for (long long i = (0); i <= ((long long)(n - 1) - 1); i++)
for (long long j = (0); j <= ((long long)(m - 1) - 1); j++) {
if (t[i][j] == 'U' && t[i][j + 1] == 'U' && t[i + 1][j] == 'D' &&
t[i + 1][j + 1] == 'D') {
t[i][j] = 'L';
t[i][j + 1] = 'R';
t[i + 1][j] = 'L';
t[i + 1][j + 1] = 'R';
bil -= 4;
res.push_back({i, j});
}
}
}
co = !co;
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
if (0) cout << fixed << setprecision(6);
cin >> n >> m;
long long pom = n * m / 2;
if (n & 1) pom *= -1;
(pom);
vector<pair<long long, long long> > a = licz(pom);
("xxx");
vector<pair<long long, long long> > b = licz(pom);
cout << ((long long)(a).size()) + ((long long)(b).size()) << "\n";
for (pair<long long, long long> el : a) {
cout << el.first + 1 << " " << el.second + 1 << "\n";
}
reverse((b).begin(), (b).end());
for (pair<long long, long long> el : b) {
cout << el.first + 1 << " " << el.second + 1 << "\n";
}
}
|
As it's the first of April, Heidi is suspecting that the news she reads today are fake, and she does not want to look silly in front of all the contestants. She knows that a newspiece is fake if it contains heidi as a subsequence. Help Heidi assess whether the given piece is true, but please be discreet about it...
Input
The first and only line of input contains a single nonempty string s of length at most 1000 composed of lowercase letters (a-z).
Output
Output YES if the string s contains heidi as a subsequence and NO otherwise.
Examples
Input
abcheaibcdi
Output
YES
Input
hiedi
Output
NO
Note
A string s contains another string p as a subsequence if it is possible to delete some characters from s and obtain p.
|
import java.util.Scanner;
public class _0381FakeNews {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String input=sc.nextLine();
String temp="heidi";
int index=0;
for(int i=0;i<input.length();i++) {
if(index==5) {
System.out.println("YES");
return;
}
if((input.charAt(i)+"").equals((temp.charAt(index)+""))){
index++;
}
}
if(index==5) {
System.out.println("YES");
}
else {
System.out.println("NO");
}
}
}
|
Makes solves problems on Decoforces and lots of other different online judges. Each problem is denoted by its difficulty — a positive integer number. Difficulties are measured the same across all the judges (the problem with difficulty d on Decoforces is as hard as the problem with difficulty d on any other judge).
Makes has chosen n problems to solve on Decoforces with difficulties a1, a2, ..., an. He can solve these problems in arbitrary order. Though he can solve problem i with difficulty ai only if he had already solved some problem with difficulty <image> (no matter on what online judge was it).
Before starting this chosen list of problems, Makes has already solved problems with maximum difficulty k.
With given conditions it's easy to see that Makes sometimes can't solve all the chosen problems, no matter what order he chooses. So he wants to solve some problems on other judges to finish solving problems from his list.
For every positive integer y there exist some problem with difficulty y on at least one judge besides Decoforces.
Makes can solve problems on any judge at any time, it isn't necessary to do problems from the chosen list one right after another.
Makes doesn't have too much free time, so he asked you to calculate the minimum number of problems he should solve on other judges in order to solve all the chosen problems from Decoforces.
Input
The first line contains two integer numbers n, k (1 ≤ n ≤ 103, 1 ≤ k ≤ 109).
The second line contains n space-separated integer numbers a1, a2, ..., an (1 ≤ ai ≤ 109).
Output
Print minimum number of problems Makes should solve on other judges in order to solve all chosen problems on Decoforces.
Examples
Input
3 3
2 1 9
Output
1
Input
4 20
10 3 6 3
Output
0
Note
In the first example Makes at first solves problems 1 and 2. Then in order to solve the problem with difficulty 9, he should solve problem with difficulty no less than 5. The only available are difficulties 5 and 6 on some other judge. Solving any of these will give Makes opportunity to solve problem 3.
In the second example he can solve every problem right from the start.
|
#include <bits/stdc++.h>
using namespace std;
void preprocess(void) { return; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(20);
preprocess();
int n;
cin >> n;
long long k;
cin >> k;
vector<int> a(n);
for (auto i = (0); i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
int cnt = 0;
;
for (auto i = (0); i < n; i++) {
;
if (k * 2 >= a[i]) {
k = max(k, (long long)a[i]);
} else {
;
for (auto j = (1); j < 34; j++) {
if (k * 2 < a[i]) {
k = k * 2;
cnt++;
} else {
break;
}
}
k = max(k, (long long)a[i]);
}
}
cout << cnt << endl;
}
|
From beginning till end, this message has been waiting to be conveyed.
For a given unordered multiset of n lowercase English letters ("multi" means that a letter may appear more than once), we treat all letters as strings of length 1, and repeat the following operation n - 1 times:
* Remove any two elements s and t from the set, and add their concatenation s + t to the set.
The cost of such operation is defined to be <image>, where f(s, c) denotes the number of times character c appears in string s.
Given a non-negative integer k, construct any valid non-empty set of no more than 100 000 letters, such that the minimum accumulative cost of the whole process is exactly k. It can be shown that a solution always exists.
Input
The first and only line of input contains a non-negative integer k (0 ≤ k ≤ 100 000) — the required minimum cost.
Output
Output a non-empty string of no more than 100 000 lowercase English letters — any multiset satisfying the requirements, concatenated to be a string.
Note that the printed string doesn't need to be the final concatenated string. It only needs to represent an unordered multiset of letters.
Examples
Input
12
Output
abababab
Input
3
Output
codeforces
Note
For the multiset {'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b'}, one of the ways to complete the process is as follows:
* {"ab", "a", "b", "a", "b", "a", "b"}, with a cost of 0;
* {"aba", "b", "a", "b", "a", "b"}, with a cost of 1;
* {"abab", "a", "b", "a", "b"}, with a cost of 1;
* {"abab", "ab", "a", "b"}, with a cost of 0;
* {"abab", "aba", "b"}, with a cost of 1;
* {"abab", "abab"}, with a cost of 1;
* {"abababab"}, with a cost of 8.
The total cost is 12, and it can be proved to be the minimum cost of the process.
|
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskC solver = new TaskC();
solver.solve(1, in, out);
out.close();
}
static class TaskC {
public void solve(int testNumber, InputReader in, PrintWriter out) {
long n = in.nextLong();
long[] t = new long[2000];
for (int i = 0; i < 2000; i++) {
t[i] = (long) i * (i - 1) / 2;
}
StringBuilder sb = new StringBuilder();
int idx = 0;
for (int i = 1999; i >= 3; i--) {
if (n >= t[i]) {
for (int j = 0; j < i; j++) {
sb.append((char) ('a' + idx));
}
idx++;
n -= t[i];
}
}
for (int i = 0; i < n; i++) {
sb.append((char) ('a' + idx));
sb.append((char) ('a' + idx));
idx++;
}
out.println("".equals(sb.toString()) ? "a" : sb.toString());
}
}
static class InputReader {
BufferedReader in;
StringTokenizer tok;
public String nextString() {
while (!tok.hasMoreTokens()) {
try {
tok = new StringTokenizer(in.readLine(), " ");
} catch (IOException e) {
throw new InputMismatchException();
}
}
return tok.nextToken();
}
public long nextLong() {
return Long.parseLong(nextString());
}
public InputReader(InputStream inputStream) {
in = new BufferedReader(new InputStreamReader(inputStream));
tok = new StringTokenizer("");
}
}
}
|
An array of positive integers a1, a2, ..., an is given. Let us consider its arbitrary subarray al, al + 1..., ar, where 1 ≤ l ≤ r ≤ n. For every positive integer s denote by Ks the number of occurrences of s into the subarray. We call the power of the subarray the sum of products Ks·Ks·s for every positive integer s. The sum contains only finite number of nonzero summands as the number of different values in the array is indeed finite.
You should calculate the power of t given subarrays.
Input
First line contains two integers n and t (1 ≤ n, t ≤ 200000) — the array length and the number of queries correspondingly.
Second line contains n positive integers ai (1 ≤ ai ≤ 106) — the elements of the array.
Next t lines contain two positive integers l, r (1 ≤ l ≤ r ≤ n) each — the indices of the left and the right ends of the corresponding subarray.
Output
Output t lines, the i-th line of the output should contain single positive integer — the power of the i-th query subarray.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preferred to use cout stream (also you may use %I64d).
Examples
Input
3 2
1 2 1
1 2
1 3
Output
3
6
Input
8 3
1 1 2 2 1 3 1 1
2 7
1 6
2 7
Output
20
20
20
Note
Consider the following array (see the second sample) and its [2, 7] subarray (elements of the subarray are colored):
<image> Then K1 = 3, K2 = 2, K3 = 1, so the power is equal to 32·1 + 22·2 + 12·3 = 20.
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct query {
int l, r, block, id;
};
const int N = 200000, Q = 200000;
int n, m, a[N], freq[1000001];
query q[Q];
ll ans[Q];
bool by_block(const query &a, const query &b) {
if (a.block != b.block) return a.block < b.block;
return a.r > b.r;
}
int main() {
scanf("%d %d", &n, &m);
int bsize = (int)sqrt(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d %d", &q[i].l, &q[i].r);
q[i].l--;
q[i].block = q[i].l / bsize;
q[i].id = i;
}
sort(q, q + m, by_block);
int curr_l = 0, curr_r = 0;
ll curr_ans = 0;
for (int i = 0; i < m; i++) {
int l = q[i].l, r = q[i].r;
while (curr_l < l) {
curr_ans += (ll)(1 - 2 * freq[a[curr_l]]) * a[curr_l];
freq[a[curr_l]]--;
curr_l++;
}
while (curr_l > l) {
curr_ans += (ll)(1 + 2 * freq[a[curr_l - 1]]) * a[curr_l - 1];
freq[a[curr_l - 1]]++;
curr_l--;
}
while (curr_r < r) {
curr_ans += (ll)(1 + 2 * freq[a[curr_r]]) * a[curr_r];
freq[a[curr_r]]++;
curr_r++;
}
while (curr_r > r) {
curr_ans += (ll)(1 - 2 * freq[a[curr_r - 1]]) * a[curr_r - 1];
freq[a[curr_r - 1]]--;
curr_r--;
}
ans[q[i].id] = curr_ans;
}
for (int i = 0; i < m; i++) {
printf("%I64d\n", ans[i]);
}
return 0;
}
|
— Willem...
— What's the matter?
— It seems that there's something wrong with Seniorious...
— I'll have a look...
<image>
Seniorious is made by linking special talismans in particular order.
After over 500 years, the carillon is now in bad condition, so Willem decides to examine it thoroughly.
Seniorious has n pieces of talisman. Willem puts them in a line, the i-th of which is an integer ai.
In order to maintain it, Willem needs to perform m operations.
There are four types of operations:
* 1 l r x: For each i such that l ≤ i ≤ r, assign ai + x to ai.
* 2 l r x: For each i such that l ≤ i ≤ r, assign x to ai.
* 3 l r x: Print the x-th smallest number in the index range [l, r], i.e. the element at the x-th position if all the elements ai such that l ≤ i ≤ r are taken and sorted into an array of non-decreasing integers. It's guaranteed that 1 ≤ x ≤ r - l + 1.
* 4 l r x y: Print the sum of the x-th power of ai such that l ≤ i ≤ r, modulo y, i.e. <image>.
Input
The only line contains four integers n, m, seed, vmax (1 ≤ n, m ≤ 105, 0 ≤ seed < 109 + 7, 1 ≤ vmax ≤ 109).
The initial values and operations are generated using following pseudo code:
def rnd():
ret = seed
seed = (seed * 7 + 13) mod 1000000007
return ret
for i = 1 to n:
a[i] = (rnd() mod vmax) + 1
for i = 1 to m:
op = (rnd() mod 4) + 1
l = (rnd() mod n) + 1
r = (rnd() mod n) + 1
if (l > r):
swap(l, r)
if (op == 3):
x = (rnd() mod (r - l + 1)) + 1
else:
x = (rnd() mod vmax) + 1
if (op == 4):
y = (rnd() mod vmax) + 1
Here op is the type of the operation mentioned in the legend.
Output
For each operation of types 3 or 4, output a line containing the answer.
Examples
Input
10 10 7 9
Output
2
1
0
3
Input
10 10 9 9
Output
1
1
3
3
Note
In the first example, the initial array is {8, 9, 7, 2, 3, 1, 5, 6, 4, 8}.
The operations are:
* 2 6 7 9
* 1 3 10 8
* 4 4 6 2 4
* 1 4 5 8
* 2 1 7 1
* 4 7 9 4 4
* 1 2 7 9
* 4 5 8 1 1
* 2 5 7 5
* 4 3 10 8 5
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<long long, long long>;
const long long INF = 1e18 + 7;
const long long N = 1e5 + 7;
const long long MOD = 1e9 + 7;
long long n, m, seed, v_max, i, j, k;
long long a[N];
long long op, l, r, x, y;
long long plusi(long long a, long long b, long long mo) {
long long cur = (0LL + a + b) % mo;
return cur;
}
long long multi(long long a, long long b, long long mo) {
a %= mo, b %= mo;
long long cur = (1LL * a * b) % mo;
return cur;
}
long long power(long long base, long long pow, long long mo) {
if (pow == 0LL) return 1LL;
if (pow == 1LL) {
base %= mo;
return base;
}
long long cur = power(base, pow / 2, mo);
cur = multi(cur, cur, mo);
if (pow % 2) cur = multi(cur, base, mo);
return cur;
}
long long rnd() {
long long cur = seed;
seed = ((seed * 7) + 13) % MOD;
return cur;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> seed >> v_max;
for (i = 1; i <= n; i++) a[i] = rnd() % v_max + 1;
queue<pii> prv, pq;
for (i = 1; i <= n; i++) {
pii u = {i, i};
pq.push(u);
}
for (i = 0; i < m; i++) {
op = rnd() % 4 + 1;
l = rnd() % n + 1;
r = rnd() % n + 1;
if (l > r) swap(l, r);
if (op == 3)
x = rnd() % (r - l + 1) + 1;
else
x = rnd() % v_max + 1;
if (op == 4) y = rnd() % v_max + 1;
if (op == 1) {
while (!pq.empty()) {
pii cur = pq.front();
pq.pop();
long long q = cur.first;
long long w = cur.second;
if (q == l && w == r) a[q] += x;
if (q == l && w < r) a[q] += x;
if (q == l && w > r)
prv.push({q, r}), a[r + 1] = a[q], a[q] += x, q = r + 1;
if (q > l && w == r) a[q] += x;
if (q > l && w > r && q <= r)
prv.push({q, r}), a[r + 1] = a[q], a[q] += x, q = r + 1;
if (q < l && w == r) prv.push({q, l - 1}), a[l] = a[q] + x, q = l;
if (q < l && w < r && w >= l)
prv.push({q, l - 1}), a[l] = a[q] + x, q = l;
if (q > l && w < r) a[q] += x;
if (q < l && w > r) {
prv.push({q, l - 1});
prv.push({r + 1, w});
a[r + 1] = a[q];
a[l] = a[q] + x;
q = l;
w = r;
}
prv.push({q, w});
}
}
if (op == 2) {
while (!pq.empty()) {
pii cur = pq.front();
pq.pop();
long long q = cur.first;
long long w = cur.second;
if (q == l && w > r) prv.push({r + 1, w}), a[r + 1] = a[q];
if (q < l && w == r) prv.push({q, l - 1});
if (q < l && w > r) {
prv.push({q, l - 1});
prv.push({r + 1, w});
a[r + 1] = a[q];
}
if (q < l && w < r && w >= l) prv.push({q, l - 1});
if (q > l && w > r && q <= r) prv.push({r + 1, w}), a[r + 1] = a[q];
if (w < l || q > r) prv.push({q, w});
}
prv.push({l, r});
a[l] = x;
}
if (op == 3) {
priority_queue<pii> ans;
while (!pq.empty()) {
pii cur = pq.front();
pq.pop();
long long q = cur.first;
long long w = cur.second;
if (q == l && w == r) ans.push({-a[q], r - l + 1});
if (q == l && w < r) ans.push({-a[q], w - l + 1});
if (q == l && w > r) ans.push({-a[q], r - l + 1});
if (q > l && w == r) ans.push({-a[q], r - q + 1});
if (q < l && w == r) ans.push({-a[q], r - l + 1});
if (q > l && w > r && q <= r) ans.push({-a[q], r - q + 1});
if (q > l && w < r) ans.push({-a[q], w - q + 1});
if (q < l && w < r && w >= l) ans.push({-a[q], w - l + 1});
if (q < l && w > r) ans.push({-a[q], r - l + 1});
prv.push({q, w});
}
long long here = 0;
long long prin = 1e18 + 7;
while (here < x) {
here += ans.top().second;
prin = -ans.top().first;
ans.pop();
}
cout << prin << "\n";
}
if (op == 4) {
long long ans = 0;
while (!pq.empty()) {
pii cur = pq.front();
pq.pop();
long long q = cur.first;
long long w = cur.second;
if (q == l && w == r) ans = multi(r - l + 1, power(a[q], x, y), y);
if (q == l && w < r)
ans = plusi(ans, multi(w - q + 1, power(a[q], x, y), y), y);
if (q == l && w > r) ans = multi(r - l + 1, power(a[q], x, y), y);
if (q > l && w == r)
ans = plusi(ans, multi(w - q + 1, power(a[q], x, y), y), y);
if (q < l && w == r) ans = multi(r - l + 1, power(a[q], x, y), y);
if (q < l && w < r && w >= l)
ans = plusi(ans, multi(w - l + 1, power(a[q], x, y), y), y);
if (q > l && w < r)
ans = plusi(ans, multi(w - q + 1, power(a[q], x, y), y), y);
if (q > l && w > r && q <= r)
ans = plusi(ans, multi(r - q + 1, power(a[q], x, y), y), y);
if (q < l && w > r) ans = multi(r - l + 1, power(a[q], x, y), y);
prv.push({q, w});
}
cout << ans << "\n";
}
while (!prv.empty()) {
pq.push(prv.front());
prv.pop();
}
}
return 0;
}
|
Will shares a psychic connection with the Upside Down Monster, so everything the monster knows, Will knows. Suddenly, he started drawing, page after page, non-stop. Joyce, his mom, and Chief Hopper put the drawings together, and they realized, it's a labeled tree!
<image>
A tree is a connected acyclic graph. Will's tree has n vertices. Joyce and Hopper don't know what that means, so they're investigating this tree and similar trees. For each k such that 0 ≤ k ≤ n - 1, they're going to investigate all labeled trees with n vertices that share exactly k edges with Will's tree. Two labeled trees are different if and only if there's a pair of vertices (v, u) such that there's an edge between v and u in one tree and not in the other one.
Hopper and Joyce want to know how much work they have to do, so they asked you to tell them the number of labeled trees with n vertices that share exactly k edges with Will's tree, for each k. The answer could be very large, so they only asked you to tell them the answers modulo 1000000007 = 109 + 7.
Input
The first line of input contains a single integer n (2 ≤ n ≤ 100) — the size of the tree.
The next n - 1 lines contain the edges of Will's tree. Each line contains two integers v and u (1 ≤ v, u ≤ n, v ≠ u), endpoints of an edge. It is guaranteed that the given graph is a tree.
Output
Print n integers in one line. i-th integer should be the number of the number of labeled trees with n vertices that share exactly i - 1 edges with Will's tree, modulo 1000 000 007 = 109 + 7.
Examples
Input
3
1 2
1 3
Output
0 2 1
Input
4
1 2
2 3
3 4
Output
1 7 7 1
Input
4
1 2
1 3
1 4
Output
0 9 6 1
|
#include <bits/stdc++.h>
long long gi() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
int pow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = 1ll * ret * x % 1000000007;
x = 1ll * x * x % 1000000007;
y >>= 1;
}
return ret;
}
int n, fir[110], dis[210], nxt[210], id;
void link(int a, int b) { nxt[++id] = fir[a], fir[a] = id, dis[id] = b; }
int siz[101], dp[101][101][101], _dp[101][101], C[101][101];
void dfs(int x, int fa = -1) {
siz[x] = 1;
dp[x][1][1] = 1;
for (int i = fir[x]; i; i = nxt[i]) {
if (dis[i] == fa) continue;
dfs(dis[i], x);
for (int j = 1; j <= siz[x]; ++j)
for (int k = 1; k <= siz[x]; ++k)
_dp[j][k] = dp[x][j][k], dp[x][j][k] = 0;
for (int j = 1; j <= siz[dis[i]]; ++j)
for (int k = 1; k <= siz[dis[i]]; ++k)
if (dp[dis[i]][j][k])
for (int J = 1; J <= siz[x]; ++J)
for (int K = 1; K <= siz[x]; ++K)
if (_dp[J][K]) {
dp[x][j + J - 1][k + K] = (dp[x][j + J - 1][k + K] +
1ll * _dp[J][K] * dp[dis[i]][j][k]) %
1000000007;
dp[x][j + J][K] =
(dp[x][j + J][K] +
1ll * _dp[J][K] * dp[dis[i]][j][k] % 1000000007 * k) %
1000000007;
}
siz[x] += siz[dis[i]];
}
}
int ans[101];
int main() {
n = gi();
int a, b;
for (int i = 1; i < n; ++i) a = gi(), b = gi(), link(a, b), link(b, a);
dfs(1);
ans[n - 1] = 1;
for (int i = n - 2, pn = 1; ~i; --i, pn = 1ll * pn * n % 1000000007) {
for (int j = 1; j <= n; ++j)
ans[i] = (ans[i] + 1ll * dp[1][n - i][j] * j) % 1000000007;
ans[i] = 1ll * ans[i] * pn % 1000000007;
}
C[0][0] = 1;
for (int i = 1; i <= n; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000007;
}
for (int i = n - 1; ~i; --i)
for (int j = i + 1; j < n; ++j)
ans[i] = (ans[i] - 1ll * C[j][i] * ans[j] % 1000000007 + 1000000007) %
1000000007;
for (int i = 0; i < n; ++i) printf("%d ", ans[i]);
return 0;
}
|
When Igor K. was a freshman, his professor strictly urged him, as well as all other freshmen, to solve programming Olympiads. One day a problem called "Flags" from a website called Timmy's Online Judge caught his attention. In the problem one had to find the number of three-colored flags that would satisfy the condition... actually, it doesn't matter. Igor K. quickly found the formula and got the so passionately desired Accepted.
However, the professor wasn't very much impressed. He decided that the problem represented on Timmy's Online Judge was very dull and simple: it only had three possible colors of flag stripes and only two limitations. He suggested a complicated task to Igor K. and the fellow failed to solve it. Of course, we won't tell anybody that the professor couldn't solve it as well.
And how about you? Can you solve the problem?
The flags consist of one or several parallel stripes of similar width. The stripes can be one of the following colors: white, black, red or yellow. You should find the number of different flags with the number of stripes from L to R, if:
* a flag cannot have adjacent stripes of one color;
* a flag cannot have adjacent white and yellow stripes;
* a flag cannot have adjacent red and black stripes;
* a flag cannot have the combination of black, white and red stripes following one after another in this or reverse order;
* symmetrical flags (as, for example, a WB and a BW flag, where W and B stand for the white and black colors) are considered the same.
Input
The only line contains two integers L and R (1 ≤ L ≤ R ≤ 109). They are the lower and upper borders of the number of stripes on the flag.
Output
Print a single number — the number of different flags that would satisfy the condition of the problem and would have from L to R stripes, modulo 1000000007.
Examples
Input
3 4
Output
23
Input
5 6
Output
64
Note
In the first test the following flags exist (they are listed in the lexicographical order, the letters B, R, W, Y stand for Black, Red, White and Yellow correspondingly):
3 stripes: BWB, BYB, BYR, RWR, RYR, WBW, WBY, WRW, WRY, YBY, YRY (overall 11 flags).
4 stripes: BWBW, BWBY, BYBW, BYBY, BYRW, BYRY, RWRW, RWRY, RYBW, RYBY, RYRW, RYRY (12 flags).
That's why the answer to test 1 is equal to 11 + 12 = 23.
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
const int W = 0, B = 1, R = 2, Y = 3;
const int N = 8;
const int mod = 1000000007;
const int inv = 500000004;
int l, r;
int mtx[N][N], a[N][N];
int st[4][4], ts[N];
bool check(int i, int j) {
if (i == j) return false;
if (j == W && i == Y) return false;
if (j == Y && i == W) return false;
if (j == R && i == B) return false;
if (j == B && i == R) return false;
return true;
}
void init() {
int tot = 0;
memset(st, -1, sizeof(st));
for (int i = 0; i < (int)(4); ++i)
for (int j = 0; j < (int)(4); ++j)
if (check(i, j)) {
st[i][j] = tot;
ts[tot++] = i * 4 + j;
}
memset(mtx, 0, sizeof(mtx));
for (int i = 0; i < (int)(N); ++i)
for (int k = 0; k < (int)(4); ++k) {
int a = ts[i] / 4;
int b = ts[i] % 4;
if (!check(b, k)) continue;
if (a == B && b == W && k == R) continue;
if (a == R && b == W && k == B) continue;
mtx[i][st[b][k]] = 1;
}
}
void add(int dst[][N], int a[][N], int b[][N]) {
int c[N][N];
for (int i = 0; i < (int)(N); ++i)
for (int j = 0; j < (int)(N); ++j) c[i][j] = (a[i][j] + b[i][j]) % mod;
memcpy(dst, c, sizeof(c));
}
void mult(int dst[][N], int a[][N], int b[][N]) {
int c[N][N];
memset(c, 0, sizeof(c));
for (int i = 0; i < (int)(N); ++i)
for (int j = 0; j < (int)(N); ++j)
for (int k = 0; k < (int)(N); ++k)
c[i][j] = (c[i][j] + (long long)a[i][k] * b[k][j]) % mod;
memcpy(dst, c, sizeof(c));
}
void power(int dst[][N], int a[][N], int k) {
int r[N][N], t[N][N];
memset(r, 0, sizeof(r));
memcpy(t, a, sizeof(t));
for (int i = 0; i < (int)(N); ++i) r[i][i] = 1;
while (k) {
if (k & 1) mult(r, t, r);
mult(t, t, t);
k >>= 1;
}
memcpy(dst, r, sizeof(r));
}
void calc(int dst[][N], int a[][N], int k) {
if (k == 1) {
memcpy(dst, a, sizeof(int) * N * N);
return;
}
int x[N][N], y[N][N];
power(x, a, k / 2);
calc(y, a, k / 2);
for (int i = 0; i < (int)(N); ++i) x[i][i]++;
mult(dst, x, y);
if (k & 1) {
power(x, a, k);
add(dst, dst, x);
}
}
int f(int n) {
if (n == 2) return 8;
int a[N][N], ans = 8;
calc(a, mtx, n - 2);
for (int i = 0; i < (int)(N); ++i)
for (int j = 0; j < (int)(N); ++j) ans = (ans + a[i][j]) % mod;
return ans;
}
int gao(int n) {
if (n == 0) return 0;
if (n == 1) return 4;
if (n == 2) return 8;
int ans = f(n) + f((n + 1) / 2);
ans = (long long)ans * inv % mod;
return (ans % mod + mod + 4) % mod;
}
void solve() {
long long ans = gao(r) - gao(l - 1);
ans = (ans % mod + mod) % mod;
printf("%d\n", (int)ans);
}
int main() {
init();
while (scanf("%d%d", &l, &r) != EOF) {
solve();
}
return 0;
}
|
Arkady wants to water his only flower. Unfortunately, he has a very poor watering system that was designed for n flowers and so it looks like a pipe with n holes. Arkady can only use the water that flows from the first hole.
Arkady can block some of the holes, and then pour A liters of water into the pipe. After that, the water will flow out from the non-blocked holes proportionally to their sizes s_1, s_2, …, s_n. In other words, if the sum of sizes of non-blocked holes is S, and the i-th hole is not blocked, (s_i ⋅ A)/(S) liters of water will flow out of it.
What is the minimum number of holes Arkady should block to make at least B liters of water flow out of the first hole?
Input
The first line contains three integers n, A, B (1 ≤ n ≤ 100 000, 1 ≤ B ≤ A ≤ 10^4) — the number of holes, the volume of water Arkady will pour into the system, and the volume he wants to get out of the first hole.
The second line contains n integers s_1, s_2, …, s_n (1 ≤ s_i ≤ 10^4) — the sizes of the holes.
Output
Print a single integer — the number of holes Arkady should block.
Examples
Input
4 10 3
2 2 2 2
Output
1
Input
4 80 20
3 2 1 4
Output
0
Input
5 10 10
1000 1 1 1 1
Output
4
Note
In the first example Arkady should block at least one hole. After that, (10 ⋅ 2)/(6) ≈ 3.333 liters of water will flow out of the first hole, and that suits Arkady.
In the second example even without blocking any hole, (80 ⋅ 3)/(10) = 24 liters will flow out of the first hole, that is not less than 20.
In the third example Arkady has to block all holes except the first to make all water flow out of the first hole.
|
n, a, b = [int(i) for i in input().split(' ')]
sizes = [int(i) for i in input().split(' ')]
st = sum(sizes)
s = (sizes[0] * a) / b
sb = st - s
blockable = sorted(sizes[1:], reverse=True)
blocked_no = 0
blocked_amount = 0
for i in range(len(blockable)):
if blocked_amount < sb:
blocked_no += 1
blocked_amount += blockable[i]
else:
break
print(blocked_no)
|
Two participants are each given a pair of distinct numbers from 1 to 9 such that there's exactly one number that is present in both pairs. They want to figure out the number that matches by using a communication channel you have access to without revealing it to you.
Both participants communicated to each other a set of pairs of numbers, that includes the pair given to them. Each pair in the communicated sets comprises two different numbers.
Determine if you can with certainty deduce the common number, or if you can determine with certainty that both participants know the number but you do not.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 12) — the number of pairs the first participant communicated to the second and vice versa.
The second line contains n pairs of integers, each between 1 and 9, — pairs of numbers communicated from first participant to the second.
The third line contains m pairs of integers, each between 1 and 9, — pairs of numbers communicated from the second participant to the first.
All pairs within each set are distinct (in particular, if there is a pair (1,2), there will be no pair (2,1) within the same set), and no pair contains the same number twice.
It is guaranteed that the two sets do not contradict the statements, in other words, there is pair from the first set and a pair from the second set that share exactly one number.
Output
If you can deduce the shared number with certainty, print that number.
If you can with certainty deduce that both participants know the shared number, but you do not know it, print 0.
Otherwise print -1.
Examples
Input
2 2
1 2 3 4
1 5 3 4
Output
1
Input
2 2
1 2 3 4
1 5 6 4
Output
0
Input
2 3
1 2 4 5
1 2 1 3 2 3
Output
-1
Note
In the first example the first participant communicated pairs (1,2) and (3,4), and the second communicated (1,5), (3,4). Since we know that the actual pairs they received share exactly one number, it can't be that they both have (3,4). Thus, the first participant has (1,2) and the second has (1,5), and at this point you already know the shared number is 1.
In the second example either the first participant has (1,2) and the second has (1,5), or the first has (3,4) and the second has (6,4). In the first case both of them know the shared number is 1, in the second case both of them know the shared number is 4. You don't have enough information to tell 1 and 4 apart.
In the third case if the first participant was given (1,2), they don't know what the shared number is, since from their perspective the second participant might have been given either (1,3), in which case the shared number is 1, or (2,3), in which case the shared number is 2. While the second participant does know the number with certainty, neither you nor the first participant do, so the output is -1.
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int> > v1, v2;
set<int> a1, a2;
void solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int first, second;
cin >> first >> second;
v1.push_back({min(first, second), max(first, second)});
}
for (int i = 0; i < m; i++) {
int first, second;
cin >> first >> second;
v2.push_back({min(first, second), max(first, second)});
}
for (int i = 0; i < n; i++) {
set<int> s1;
for (int k = 0; k < m; k++) {
if (v1[i] == v2[k]) continue;
multiset<int> s;
s.insert(v1[i].first);
s.insert(v1[i].second);
s.insert(v2[k].first);
s.insert(v2[k].second);
if (s.count(v1[i].first) == 2) {
s1.insert(v1[i].first);
}
if (s.count(v1[i].second) == 2) {
s1.insert(v1[i].second);
}
}
if ((int)s1.size() > 1) {
cout << -1 << '\n';
return;
}
if ((int)s1.size() == 1) {
a1.insert(*s1.begin());
}
}
swap(v1, v2);
for (int i = 0; i < m; i++) {
set<int> s1;
for (int k = 0; k < n; k++) {
if (v1[i] == v2[k]) continue;
multiset<int> s;
s.insert(v1[i].first);
s.insert(v1[i].second);
s.insert(v2[k].first);
s.insert(v2[k].second);
if (s.count(v1[i].first) == 2) {
s1.insert(v1[i].first);
}
if (s.count(v1[i].second) == 2) {
s1.insert(v1[i].second);
}
}
if ((int)s1.size() > 1) {
cout << -1 << '\n';
return;
}
if ((int)s1.size() == 1) {
a2.insert(*s1.begin());
}
}
if ((int)a1.size() == 1 and (int) a2.size() == 1) {
cout << *a1.begin() << '\n';
} else {
cout << 0 << '\n';
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
Ashu is very fond of Prime numbers and he like challenging his friends by giving them various problems based on Mathematics and Prime number. One of his friend Harshit is jealous and challenges him to solve a task. Task is :Given a prime number X, you need to give the count of all numbers in range 1 to 10^6 inclusive which have minimum prime factor X.Help Ashu in solving this task.Input:First line consist of numer of test cases T.Each test case contains a single number X.Output:Output for each test case count of all numbers in range 1 to 10^6 inclusive which have minimum prime factor X.Constraints:1 ≤ T ≤ 10^5Prime number X where 2 ≤ X ≤ 10^6
SAMPLE INPUT
2
2
11
SAMPLE OUTPUT
500000
20779
Explanation
The minimum prime factor of all even numbers in the range [2, 1000000] is 2, and there are 1000000/2 = 500000 such even numbers.
The numbers with minimum prime factor as 11 are: 11, 121, 143, ...
|
MAX = 10**6+1
primes = [1]*MAX
primes[0] = primes[1] = 0
for i in xrange(2,MAX):
if primes[i]:
for j in xrange(i*i,MAX,i):
if primes[j]:
primes[i] += 1
primes[j] = 0
for _ in xrange(input()):
x = input()
print primes[x]
|
Little Chiku is very choosy about numbers. He considers 0 and 1 together as bad omen. So he hates 0 and 1 appearing adjacent to each other. So he wants you to remove these 0 and 1 combinations from a string. So you proceed like this : Choose any two adjacent positions in the string, and if one them contains 0, and the other contains 1, then you are allowed to remove these two digits from the string, obtaining a string of length n-2 as a result.
Now Chiku ponders about what is the minimum length of the string that will remain after applying the above operation repeatedly many times (possibly, zero) .Help little Chiku to calculate this number.
Input:
First line contains T, the number of test cases to follow. (1 ≤ T ≤ 1000)
Each test case contains the string of length n consisting only from zeros and ones. (1 ≤ n ≤ 2*10^5),
Output:
Output the minimum length of the string that may remain after applying the described operations several times.
SAMPLE INPUT
3
11101111
1100
01010
SAMPLE OUTPUT
6
0
1
Explanation
**Sample Input**
3
11101111
1100
01010
**Output:**
6
0
1
**Explanation**
In the sample test it is possible to change the string like the following:
11101111-> removing adjacent zero and one from the string ->111111(String of length 6 remains)
Likewise:
1100->remove adjacent zero and one->10-> remove adjacent zero and one ->None(0 length string remains)
01010-> remove adjacent zero and one-> 010-> remove adjacent zero and one ->0 (1 length string remains)
|
tc=int(raw_input())
for case in range(tc):
s=raw_input()
l=len(s)
z=s.count("0")
o=s.count("1")
if z<o:
print l-z*2
else:
print l-o*2
|
Results are out and admission process has begun in most of the colleges. This is the story of two such young engineering aspirants, Ramesh and Suresh, who intend to make it big in life.
They met each other during the admission phase of some college and have become friends. But that does not mean they aren't competitors. They both have scored the exact same marks in JEE Mains and also in their boards and so, right now, it's a tie on who is more intelligent. No one likes ties, so in order to determine who is the smarter of them both they decided to ask a Mathematics Professor, at the college they currently are applying to, to give both of them a problem to solve and the one who solves it first is smarter. By now it should be evident that the strong point of both of them is Mathematics.
The mathematics professor had been in that college since its inception and had seen plenty such Ramesh and Suresh pairs competing each other. It was no big deal for him as this happened quite a lot and he found such competition healthy. He gave them both a very simple task which was to find the Ramanujan Number but not just any Ramanujan Number.
He would simply give them a number, N, and they would have to find the Nth Ramanujan Number. Also, finding the number just once would not be a wise option and so he would repeat the same thing several times.
You are here, not just to see who wins between Ramesh and Suresh. Your task is to help the professor. You don't expect him to remember all the Ramanujan Numbers by heart, do you? But in order to determine the winner, the professor must himself know the answer. Provide him with the answer key so that he shall determine the winner!
Input:
First line of input will contain a number, t. It is the number of numbers the professor gives them both. Each of the next t lines would contain a number, N.
Output:
t lines, each of which contain the Nth Ramanujan Number.
Constraints:
1 ≤ t ≤ 15
1 ≤ N ≤ 100
SAMPLE INPUT
1
1
SAMPLE OUTPUT
1729
|
def numbers(N):
my_number = 0
v = {}
c = {}
i = 0
while my_number < N:
c[i] = i * i * i
for j in xrange(i):
s = c[j] + c[i]
if s in v:
my_number += 1
yield(s)
v[s] = (j,i)
i += 1
my = []
def m(N):
for x in numbers(N):
my.append(x)
m(100)
T = int(raw_input())
for _ in xrange(T):
N = int(raw_input())
print my[N-1]
|
Gudi enters the castle, and moves along the main path. Suddenly, a block in the ground opens and she falls into it! Gudi slides down and lands in a dark room. A mysterious voice announces:
Intruders are not allowed inside the castle. To proceed, you must
solve my puzzle. Here is a string S indexed from 1 to N,
consisting of digits from 0-9. If you summon the spell "Sera", the
string will be rotated clockwise by H positions. If you summon the
spell "Xhaka", the number A will be added to all the even-indexed
digits of the string. For example, if H = 1 A = 3 "Sera" and
"Xhaka" on the string "781" will result in strings ""178" and "711"
respectively i.e. digits post 9 are cycled back to 0. The objective is
to obtain the lexicographically smallest string possible as a result
of applying any of the two spells any number of times in any order. Find the string
and I shall set you free
Input
The first line contains an integer T. T testcases follow.
First line of each test contains the string S.
The next line contains two space-separated integers A and H.
Output
Print the answer to each testcase in a new line.
Constraints
1 ≤ T ≤ 10
1 ≤ N, H ≤ 6
1 ≤ A ≤ 10
SAMPLE INPUT
2
31
4 1
160
9 2
SAMPLE OUTPUT
11
000
Explanation
For the first testcase, we can summon the spells as:
31 --(Sera)- -> 13 --(Xhaka)- -> 17 --(Xhaka)- -> 11, and it is the smallest possible answer.
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# https://www.hackerearth.com/july-easy-16/algorithm/gudi-trapped-in-the-room-july-easy/
from collections import deque
def increment_string(s, n, a):
start, mul = (0, 1)
if n % 2 == 1:
start, mul = (1, 10)
for i in xrange(start, n, 2):
digit = (s // mul) % 10
s -= digit * mul
digit += a
digit %= 10
s += digit * mul
mul *= 100
return s
def rotate_string(s, mul, h):
for i in xrange(0, h):
digit = s % 10
s //= 10
s += digit * mul
return s
T = int(raw_input())
for _ in xrange(0, T):
S = raw_input()
n = len(S)
S = int(S)
A, H = [int(x) for x in raw_input().split()]
mul = 10 ** (n - 1)
stack = deque()
stack.append(S)
seen = set()
min_s = S
while len(stack) != 0:
s = stack.popleft()
if not s in seen:
min_s = min(min_s, s)
seen.add(s)
stack.append(increment_string(s, n, A))
stack.append(rotate_string(s, mul, H))
print str(min_s).zfill(n)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.