input
stringlengths 29
13k
| output
stringlengths 9
73.4k
|
|---|---|
We have a graph with N vertices and M edges, and there are two people on the graph: Takahashi and Aoki.
The i-th edge connects Vertex U_i and Vertex V_i. The time it takes to traverse this edge is D_i minutes, regardless of direction and who traverses the edge (Takahashi or Aoki).
Takahashi departs Vertex S and Aoki departs Vertex T at the same time. Takahashi travels to Vertex T and Aoki travels to Vertex S, both in the shortest time possible. Find the number of the pairs of ways for Takahashi and Aoki to choose their shortest paths such that they never meet (at a vertex or on an edge) during the travel, modulo 10^9 + 7.
Constraints
* 1 \leq N \leq 100 000
* 1 \leq M \leq 200 000
* 1 \leq S, T \leq N
* S \neq T
* 1 \leq U_i, V_i \leq N (1 \leq i \leq M)
* 1 \leq D_i \leq 10^9 (1 \leq i \leq M)
* If i \neq j, then (U_i, V_i) \neq (U_j, V_j) and (U_i, V_i) \neq (V_j, U_j).
* U_i \neq V_i (1 \leq i \leq M)
* D_i are integers.
* The given graph is connected.
Input
Input is given from Standard Input in the following format:
N M
S T
U_1 V_1 D_1
U_2 V_2 D_2
:
U_M V_M D_M
Output
Print the answer.
Examples
Input
4 4
1 3
1 2 1
2 3 1
3 4 1
4 1 1
Output
2
Input
3 3
1 3
1 2 1
2 3 1
3 1 2
Output
2
Input
8 13
4 2
7 3 9
6 2 3
1 6 4
7 6 9
3 8 9
1 2 2
2 8 12
8 6 9
2 5 5
4 2 18
5 3 7
5 1 515371567
4 8 6
Output
6
|
// In The Name Of Allah
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <int, int> pii;
#define error(x) cout << #x << " = " << x << endl;
const int N = 1e5 + 5, mod = 1e9 + 7;
const ll inf = 1e15;
inline int sum(int a, int b) {
a += b;
if(a >= mod)
a -= mod;
if(a < 0)
a += mod;
return a;
}
inline int mult(int a, int b) {
return (1LL * a * b) % mod;
}
int n, m, dp[N][2], S, T;
ll dist[N][2];
vector <pii> adj[N];
vector <pair <pii, int> > edge;
inline void dijkstra(int src, int id) {
for (int i = 0; i < n; i++)
dist[i][id] = inf;
dp[src][id] = 1;
dist[src][id] = 0;
set <pair <ll, int>> s;
s.insert({0, src});
while(!s.empty()) {
pair <ll, int> p = (*s.begin());
s.erase(p);
int v = p.second;
for (auto e : adj[v]) {
int u = e.first, w = e.second;
if(dist[u][id] > dist[v][id] + w) {
s.erase({dist[u][id], u});
dist[u][id] = dist[v][id] + w;
s.insert({dist[u][id], u});
dp[u][id] = dp[v][id];
}
else if(dist[u][id] == dist[v][id] + w)
dp[u][id] = sum(dp[u][id], dp[v][id]);
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> S >> T;
S--, T--;
for (int i = 0; i < m; i++) {
int v, u, w;
cin >> v >> u >> w;
v--, u--;
adj[v].push_back({u, w});
adj[u].push_back({v, w});
edge.push_back({{u, v}, w});
}
dijkstra(S, 0);
dijkstra(T, 1);
int ans = mult(dp[S][1], dp[T][0]);
for (int i = 0; i < n; i++) {
if(dist[i][0] == dist[i][1]) {
ans = sum(ans, - mult(mult(dp[i][0], dp[i][0]), mult(dp[i][1], dp[i][1])));
}
}
//*
for (auto e : edge) {
int vv = e.first.first, uu = e.first.second, w = e.second;
for (auto x : {make_pair(vv, uu), make_pair(uu, vv)}) {
int v = x.first, u = x.second;
if(dist[v][0] < (dist[S][1] / 2) && dist[u][1] < (dist[S][1] / 2) && dist[v][0] + dist[u][1] + w == dist[S][1]) {
ans = sum(ans, -mult(mult(dp[v][0], dp[u][1]), mult(dp[v][0], dp[u][1])));
}
}
}
//*/
cout << ans << "\n";
}
|
You are given an integer sequence of length N, a_1,a_2,...,a_N.
For each 1≤i≤N, you have three choices: add 1 to a_i, subtract 1 from a_i or do nothing.
After these operations, you select an integer X and count the number of i such that a_i=X.
Maximize this count by making optimal choices.
Constraints
* 1≤N≤10^5
* 0≤a_i<10^5 (1≤i≤N)
* a_i is an integer.
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 .. a_N
Output
Print the maximum possible number of i such that a_i=X.
Examples
Input
7
3 1 4 1 5 9 2
Output
4
Input
10
0 1 2 3 4 5 6 7 8 9
Output
3
Input
1
99999
Output
1
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100001];
int main() {
cin >> n;
for(int i = 0; i < n; i++) {
int x;
cin >> x;
if(x > 0) a[x-1]++;
a[x]++;
a[x+1]++;
}
int ans = 0;
for(int i = 0; i < 100001; i++) {
ans = max(ans,a[i]);
}
cout << ans << endl;
}
|
Snuke received an integer sequence a of length 2N-1.
He arbitrarily permuted the elements in a, then used it to construct a new integer sequence b of length N, as follows:
* b_1 = the median of (a_1)
* b_2 = the median of (a_1, a_2, a_3)
* b_3 = the median of (a_1, a_2, a_3, a_4, a_5)
* :
* b_N = the median of (a_1, a_2, a_3, ..., a_{2N-1})
How many different sequences can be obtained as b? Find the count modulo 10^{9} + 7.
Constraints
* 1 ≤ N ≤ 50
* 1 ≤ a_i ≤ 2N-1
* a_i are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_{2N-1}
Output
Print the answer.
Examples
Input
2
1 3 2
Output
3
Input
4
1 3 2 3 2 4 3
Output
16
Input
15
1 5 9 11 1 19 17 18 20 1 14 3 3 8 19 15 16 29 10 2 4 13 6 12 7 15 16 1 1
Output
911828634
|
#include<bits/stdc++.h>
using namespace std;
long long read()
{
char ch=getchar();long long x=0,ff=1;
while(ch<'0'||ch>'9') {if(ch=='-') ff=-1;ch=getchar();}
while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
return x*ff;
}
void write(long long aa)
{
if(aa<0) putchar('-'),aa=-aa;
if(aa>9) write(aa/10);
putchar('0'+aa%10);
return;
}
const long long mod=1e9+7;
long long n,ans;
long long a[105],f[55][105][105],vis[105];
int main()
{
n=read();
for(long long i=1;i<=2*n-1;++i) a[i]=read();
sort(a+1,a+2*n);
for(int i=n-1;i;--i) if(a[i+1]==a[i]) vis[i]=1;
for(int i=n+1;i<2*n;++i) if(a[i-1]==a[i]) vis[i]=1;
f[1][1][0]=1;
for(long long i=2;i<=n;++i)
{
for(long long l=0;l<=2*n-1;++l)
for(long long r=0;r<=2*n-1;++r) if(f[i-1][l][r])
{
int L=l+1-vis[n-i+1],R=r+1-vis[n+i-1];
for(int k=1;k<=L+R;++k)
{
if(k<L) (f[i][k][R+1]+=f[i-1][l][r])%=mod;
else if(k==L) (f[i][k][R]+=f[i-1][l][r])%=mod;
else (f[i][L+1][R-k+L]+=f[i-1][l][r])%=mod;
}
}
}
for(long long i=0;i<=n*2-1;++i)
for(long long j=0;j<=n*2-1;++j) (ans+=f[n][i][j])%=mod;
write(ans);
return 0;
}
|
In the country there are N cities numbered 1 through N, which are connected by N-1 bidirectional roads. In terms of graph theory, there is a unique simple path connecting every pair of cities. That is, the N cities form a tree. Besides, if we view city 1 as the root of this tree, the tree will be a full binary tree (a tree is a full binary tree if and only if every non-leaf vertex in the tree has exactly two children). Roads are numbered 1 through N-1. The i-th road connects city i+1 and city a_i. When you pass through road i, the toll you should pay is v_i (if v_i is 0, it indicates the road does not require a toll).
A company in city 1 will give each employee a family travel and cover a large part of the tolls incurred. Each employee can design the travel by themselves. That is, which cities he/she wants to visit in each day and which city to stay at each night. However, there are some constraints. More details are as follows:
* The travel must start and end at city 1. If there are m leaves in the tree formed by the cities, then the number of days in the travel must be m+1. At the end of each day, except for the last day, the employee must stay at some hotel in a leaf city. During the whole travel, the employee must stay at all leaf cities exactly once.
* During the whole travel, all roads of the country must be passed through exactly twice.
* The amount that the employee must pay for tolls by him/herself is the maximum total toll incurred in a single day during the travel, except the first day and the last day. The remaining tolls will be covered by the company.
Shik, as an employee of this company, has only one hope for his travel. He hopes that the amount he must pay for tolls by himself will be as small as possible. Please help Shik to design the travel which satisfies his hope.
Constraints
* 2 < N < 131,072
* 1 \leq a_i \leq i for all i
* 0 \leq v_i \leq 131,072
* v_i is an integer
* The given tree is a full binary tree
Input
The input is given from Standard Input in the following format:
N
a_1 v_1
a_2 v_2
:
a_{N-1} v_{N-1}
Output
Print an integer denoting the minimum amount Shik must pay by himself for tolls incurred during the travel.
Examples
Input
7
1 1
1 1
2 1
2 1
3 1
3 1
Output
4
Input
9
1 2
1 2
3 2
3 2
5 2
5 2
7 2
7 2
Output
6
Input
15
1 2
1 5
3 3
4 3
4 3
6 5
5 4
5 3
6 3
3 2
11 5
11 3
13 2
13 1
Output
15
Input
3
1 0
1 0
Output
0
|
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long ll;
struct Pr{
ll x,y;
}l_r[210000],r_l[210000];
struct Te{
int ls,rs,lv,rv;
}t[210000];
int n;
ll mid;
vector<Pr>V[210000];
void insert(int x,Pr y){
//x sorted
//compare y is ok
int i=V[x].size()-1;
if(V[x].empty()){V[x].push_back(y);return;}
if(V[x][i].y<=y.y)return;
while(!V[x].empty()&&V[x][i].x>=y.x)V[x].pop_back();
V[x].push_back(y);
}
int dfs(int u){
V[u].clear();
int i,j,ltor=0,rtol=0,dt=t[u].lv+t[u].rv;
int ls=t[u].ls,rs=t[u].rs,lv=t[u].lv,rv=t[u].rv;
if(t[u].ls==0){
insert(u,(Pr){0,0});
return 1;
}int jud=dfs(t[u].ls)&&dfs(t[u].rs);
if(jud==0)return 0;
//stay x/ y\
//using combine
for(i=V[ls].size()-1,j=V[rs].size()-1;i>=0;i--)
{
while(j>=0&&V[ls][i].y+V[rs][j].x+dt>mid) j--;
if(j>=0) l_r[++ltor]=(Pr){V[ls][i].x+lv,V[rs][j].y+rv};
}
for(i=V[ls].size()-1,j=V[rs].size()-1;j>=0;j--)
{
while(i>=0&&V[ls][i].x+V[rs][j].y+dt>mid) i--;
if(i>=0) r_l[++rtol]=(Pr){V[rs][j].x+rv,V[ls][i].y+lv};
}
reverse(l_r+1,l_r+ltor+1);
reverse(r_l+1,r_l+rtol+1);
i=1;j=1;
while(i<=ltor&&j<=rtol){
if(l_r[i].x<r_l[j].x){insert(u,l_r[i]);i++;}
else {insert(u,r_l[j]);j++;}
}while(i<=ltor){insert(u,l_r[i]);i++;}
while(j<=rtol){insert(u,r_l[j]);j++;}
return !V[u].empty();
}
int main(){
int x,y;
scanf("%d",&n);
ll L=-1,R=17179869184ll;
for(int i=2;i<=n;i++){
scanf("%d %d",&x,&y);
if(t[x].ls==0)t[x].ls=i,t[x].lv=y;
else t[x].rs=i,t[x].rv=y;
}while(L+1<R){
mid=(L+R)>>1;
if(dfs(1)){
R=mid;
}else L=mid;
}printf("%lld\n",R);
return 0;
}
|
<image>
There is a container that is bifurcated as shown in the figure. Drop 10 balls numbered from 1 to 10 through the opening A of the container and place the balls in the left cylinder B or the right cylinder C. Since plate D can rotate left and right around the fulcrum E, you can move plate D to decide whether to put it in cylinder B or cylinder C.
Gives a sequence of balls to drop from opening A. Put them in cylinder B or cylinder C in order. At this time, create a program that outputs YES if both cylinder B and cylinder C can arrange large balls on the small numbered balls, and NO if they cannot be arranged. However, the order of the balls cannot be changed in the container. In addition, it is assumed that they can be put in the same cylinder in succession, and that there is enough room for all 10 balls in both cylinders B and C.
Input
Given multiple datasets. The number of datasets N is given in the first line. Then you are given a dataset of N rows. Each dataset is given 10 numbers, starting from the left, separated by blanks.
Output
Print YES or NO on one line for each dataset.
Example
Input
2
3 1 4 2 5 6 7 8 9 10
10 9 8 7 6 5 4 3 2 1
Output
YES
NO
|
n=int(input())
i=1
while i<=n:
ball=list(map(int,input().split()))
left=[0]
right=[0]
m=0
while True:
#終了条件
if m==10:
print("YES")
#print("left",left,"right",right)
break
#noの条件
if ball[m]<left[len(left)-1] and ball[m]<right[len(right)-1]:
print("NO")
#print("left",left,"right",right,"ball",ball[m])
break
#左側に入れるか右側に入れるかの条件
if ball[m]>left[len(left)-1] and ball[m]>right[len(right)-1]:
if left[len(left)-1]>right[len(right)-1]:
left.append(ball[m])
else:
right.append(ball[m])
elif ball[m]>left[len(left)-1]:
left.append(ball[m])
else:
right.append(ball[m])
m+=1
i+=1
|
The king of a country loves prime numbers and gambling. The unit of currency in this country is called prime. As of November 1, 2007, Prime's cross-yen rate was just prime at 9973, so the King is overjoyed. Subsidiary coins with 1/101 prime as one subprime are used in this country.
The government of this country has decided to establish a lottery promotion corporation and start a lottery business with the aim of simultaneously satisfying the stability of national finances, the entertainment of the people, and the hobbies of the king. A king who loves prime numbers will be satisfied with the topic of prime numbers and want to win a prize. Therefore, the promotion public corporation considered the following lottery ticket.
* The lottery is numbered from 0 to MP. MP is the largest prime number known in the country and is published in the official bulletin on the first day of every month. At the same time, all prime numbers below MP will be announced. Even if a larger prime number is discovered, all public institutions, including the Lottery Promotion Corporation, will treat the MP announced per day as the largest prime number during the month. On November 1, 2007, MP = 999983 (the largest prime number less than or equal to 1000000) was announced.
* The selling price of the lottery is 1 subprime.
* In the lottery lottery, several pairs (p, m) of winning lottery number p and several m for prize calculation are selected. p and m are integers greater than or equal to 0 and less than or equal to MP, respectively.
* If there are X prime numbers known in this country that are greater than or equal to p --m and less than or equal to p + m, the prize of the lottery result (p, m) will be X prime.
* The prize money X prime of the lottery result (p, m) will be paid to the winner who has the lottery number p, but in some cases X = 0, in which case the prize money will not be paid to the winner.
* One of the prizes will be paid from the lottery sales and the X-1 prime will be paid from the King's court fees (paid by the King). If X = 0, 1 prime will be transferred to the court fee from the lottery sales. (Paid to the king)
* One number p can be multiple winning lottery. In this case, the total prize money calculated from each lottery result (p, m) will be paid to the winners.
In this lottery, the person who bought the winning lottery searches for the relevant prime numbers from the lottery results and counts the number, so the prime numbers often appear in the topic of the people and the king is very happy. As a lottery promotion public corporation, the public corporation bears 1 prime per lottery and the selling price is 1 sub-prime, so if the number of winning lottery n is reduced to 1 or less per 101 lottery sold (that is, n). ≤ (If the number sold) / 101, it will not be in the red.
The problem is the amount spent from court fees. Your job is to create a program that takes the lottery results as input and outputs the amount of prize money that the Lottery Promotion Corporation will charge the King in November 2007. However, the amount of prize money to be charged shall not be negative.
Note
* The definition of prime numbers in this country is the same as what you learn in Japanese school education. That is, a prime number is a natural number that has no divisor other than 1 and itself (note that 1 is not a prime number).
* We know that 1000003 is a prime number, but it is not known in this country as of November 2007. Therefore, there are only two known prime numbers in this country, ranging from 999963 to 1000003, 999983 and 999979.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 m1
p2 m2
::
pn mn
The number of lottery results n (1 ≤ n ≤ 1000000) is given in the first line, and the i-th lottery result information pi and mi are given in the following n lines, separated by blanks.
The number of datasets does not exceed 20.
Output
The amount billed to the king for each data set is output in one line in prime units (integer).
Example
Input
4
5 0
9 1
3 10
11 3
1
999983 20
0
Output
5
1
|
#include <iostream>
#include <stdio.h>
using namespace std;
int pr[1000003];
int main() {
int i,j,n,p,m,f,e,g;
for (i=2;i<1000000;i++) if (pr[i]==0) { pr[i]=2; for (j=i*2;j<1000000;j+=i) pr[j]=1;}
for (i=2,j=0;i<1000000;i++) { j+=pr[i]>1; pr[i]=j; }
while(cin >> n) {
if (n==0) break;
g=0;
for (;n>0;n--) {
cin >> p >> m;
f=p-m<0 ? 0 : p-m;
e=p+m>999999 ? 999999 : p+m;
j=pr[e]-pr[f-1];
if (j==0) g--; else g+=j-1;
}
cout << g << endl;
}
return 0;
}
|
On the Internet shopping site, on the same page as the product that the user is currently viewing, some other products that other users have bought in the past along with the product that they are currently viewing are displayed. It is believed that sales can be increased by presenting products that are considered to be highly relevant.
Similar things can be seen in local supermarkets (such as bread and jam) as a way to place items that are often bought together nearby. Your job is to write a program that will help you devise product placement. This time, I would like to set a certain standard number of times and find a combination of two products for which the number of times bought together is equal to or greater than the standard number of times.
When given the information of the products bought together and the standard number of times, create a program that outputs the combination of the two products bought together more than the standard number of times.
Input
The input is given in the following format.
N F
info1
info2
::
infoN
The first line gives the number of pieces of information N (1 ≤ N ≤ 100) and the reference number F (1 ≤ F ≤ 100) of the items bought together. The following N lines are given information on the products bought together. Information about the products bought together infoi is given in the following format.
M item1 item2 ... itemM
M (1 ≤ M ≤ 10) indicates how many products this information contains. itemj is the name of the item bought in this purchase and is a string of 1 to 30 length consisting of only lowercase letters. The same product is never given in infoi.
Output
The number of combinations of two products bought together more than the reference number of times is output on the first line, and all combinations are output on the second and subsequent lines. However, if there is no combination, nothing is output after the second line.
The output order is as follows after arranging the product names in the combination in the lexicographic order (the order in which the words are arranged in the English-Japanese dictionary).
* Compare the first product names, and the one with the earliest in lexicographic order comes first.
* If they are the same, compare the second product names and the lexicographic order comes first.
Separate product names with a single space, and separate product combinations with a single line break.
Examples
Input
5 2
3 bread milk banana
2 milk cornflakes
3 potato bread milk
4 cornflakes bread milk butter
2 potato bread
Output
3
bread milk
bread potato
cornflakes milk
Input
5 5
3 bread milk banana
2 milk cornflakes
3 potato bread milk
4 cornflakes bread milk butter
2 potato bread
Output
0
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
using namespace std;
struct Info{
char name[31];
};
struct Ans{
char left[31],right[31];
};
bool strCmp(char* base, char* comp){
int length1 = 0,length2 = 0;
for(int i=0;base[i] != '\0'; i++)length1++;
for(int i=0;comp[i] != '\0'; i++)length2++;
if(length1 != length2)return false;
for(int i=0;base[i] != '\0'; i++){
if(base[i] != comp[i])return false;
}
return true;
}
void strcpy(char* to,char* str){
for(int i=0;str[i] != '\0';i++){
to[i] = str[i];
to[i+1] = '\0';
}
}
int strCmp2(char* left,char* right){
int i;
if(strCmp(left,right))return 3;
for(i=0;left[i] != '\0' && right[i] != '\0'; i++){
if(left[i] != right[i]){
if(left[i] < right[i])return 1;
else{
return 2;
}
}
}
if(left[i] == '\0')return 1;
else{
return 2;
}
}
int main(){
int F,N,index,base;
scanf("%d %d",&N,&F);
int num_of_data[N];
int** data = new int*[N];
for(int i = 0; i < N; i++){
data[i] = new int[10];
}
int** checkTable = new int*[1000];
for(int i = 0; i < 1000; i++){
checkTable[i] = new int[1000];
for(int k = 0; k < 1000; k++)checkTable[i][k] = 0;
}
Info info[10*N];
index = 0;
char buf[31];
bool FLG;
for(int loop = 0; loop < N; loop++){
scanf("%d",&num_of_data[loop]);
for(int i = 0; i < num_of_data[loop];i++){
scanf("%s",buf);
FLG = false;
for(int k = 0; k < index; k++){
if(strCmp(info[k].name,buf)){
FLG = true;
data[loop][i] = k;
break;
}
}
if(!FLG){
strcpy(info[index].name,buf);
data[loop][i] = index;
index++;
}
}
}
for(int loop = 0; loop < N; loop++){
for(int i = 0; i < num_of_data[loop];i++){
base = data[loop][i];
for(int k = 0; k < num_of_data[loop];k++){
if(k != i){
checkTable[base][data[loop][k]]++;
}
}
}
}
Ans* ans = (Ans*)malloc(sizeof(Ans)*(index*index));
int ans_index = 0;
for(int i = 0; i < index-1; i++){
for(int k = i+1; k < index; k++){
if(checkTable[i][k] >= F){
if(strCmp2(info[i].name,info[k].name) == 1){
strcpy(ans[ans_index].left,info[i].name);
strcpy(ans[ans_index].right,info[k].name);
ans_index++;
}else{
strcpy(ans[ans_index].left,info[k].name);
strcpy(ans[ans_index].right,info[i].name);
ans_index++;
}
}
}
}
for(int i = 1; i <= ans_index-1; i++){
for(int k = ans_index-1; k >= i;k--){
if(strCmp2(ans[k].left,ans[k-1].left) == 1)swap(ans[k],ans[k-1]);
else if(strCmp2(ans[k].left,ans[k-1].left) == 3 && strCmp2(ans[k].right,ans[k-1].right) == 1)swap(ans[k],ans[k-1]);
}
}
printf("%d\n",ans_index);
for(int i = 0; i < ans_index; i++){
printf("%s %s\n",ans[i].left,ans[i].right);
}
return 0;
}
|
problem
You love pasta, and you make and eat pasta for dinner every day. You can make three types of pasta: tomato sauce, cream sauce, and basil sauce.
I decided to plan a dinner for N days. Choose one of the three types of pasta each day. However, if the same pasta continues, you will get bored, so do not choose the same pasta for more than 3 consecutive days. Also, the pasta for K days out of N days has already been decided.
Given the value of N and the pasta information for K days as input, create a program that finds the remainder of dividing by 10000 how many plans are to meet the conditions.
input
The input consists of K + 1 lines.
On the first line, two integers N and K (3 ≤ N ≤ 100, 1 ≤ K ≤ N) are written with a blank as a delimiter.
On the 1 + i line (1 ≤ i ≤ K), two integers Ai and Bi (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ 3) are written with a blank as a delimiter. This means that the pasta on the Ai day has already been decided, and when Bi = 1, it is a tomato sauce, when Bi = 2, it is a cream sauce, and when Bi = 3, it is a basil sauce. Ai (1 ≤ i ≤ K) are all different. It is guaranteed that there will be at least one plan to meet the conditions in the given input data.
output
Divide the number of plans to satisfy the condition by 10000 and output the remainder in one line.
Input / output example
Input example 1
5 3
3 1
1 1
4 2
Output example 1
6
In I / O Example 1, you consider a 5-day schedule. The first and third days are tomato sauce, and the fourth day is cream sauce. Also, do not choose the same pasta for more than 3 consecutive days. There are six plans to meet these conditions.
1st day | 2nd day | 3rd day | 4th day | 5th day
--- | --- | --- | --- | --- | ---
Schedule 1 | 1 | 2 | 1 | 2 | 1
Schedule 2 | 1 | 2 | 1 | 2 | 2
Schedule 3 | 1 | 2 | 1 | 2 | 3
Schedule 4 | 1 | 3 | 1 | 2 | 1
Schedule 5 | 1 | 3 | 1 | 2 | 2
Schedule 6 | 1 | 3 | 1 | 2 | 3
In this table, 1 represents tomato sauce, 2 represents cream sauce, and 3 represents basil sauce.
Input example 2
20 5
10 2
4 3
12 1
13 2
9 1
Output example 2
2640
In I / O Example 2, there are a total of 4112640 plans to meet the conditions. It outputs 2640, which is the remainder of dividing it by 10000.
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
5 3
3 1
1 1
4 2
Output
6
|
#include <iostream>
#include <map>
using namespace std;
int n,k;
int memo[4][4][4][102];
map <int,int> ma;
int rec(int b,int y,int t,int idx){
if(b == y && y == t) return 0;
if(ma[idx] != '\0' && ma[idx] != t) return 0;
if(idx == n) return 1;
if(memo[b][y][t][idx] != 0) return memo[b][y][t][idx];
return memo[b][y][t][idx] = (rec(y,t,1,idx+1) + rec(y,t,2,idx+1) + rec(y,t,3,idx+1))%10000;
}
int main(){
cin >> n >> k;
for(int i=0;i<k;i++){
int t,m; cin >> t >> m; ma[t] = m;
}
int ans = (rec(0,0,1,1) + rec(0,0,2,1) + rec(0,0,3,1))%10000;
cout << ans << endl;
}
|
Problem
KND is a student programmer at the University of Aizu. His neighbor is known to be very annoying. Neighbors find out that he is a sweet tooth and plan to add more sweetness than necessary to make him fat. To that end, your neighbor, you, was introduced to a sweets shop by a friend.
However, the way products are sold at the sweets shop has changed a little. The selling method is to sell a set of sweets called a sweetness set on a daily basis. If you are on a budget, you can freely buy sweets from the sweets set sold on that day. However, only one sweetness included in the sweetness set is sold for each type. In addition, the budget shall be paid from the amount prepared at the beginning of the period, and there shall be no additional budget during the period. You decide to create a program to calculate how to buy sweets that will optimally gain his weight over a period of time within a certain budget, based on the degree and price of the effect of sweetness on weight taught by a friend. did.
Constraints
The input satisfies the following conditions.
* All inputs are integers.
* 1 ≤ s ≤ d ≤ 100
* 1 ≤ m ≤ 300
* 1 ≤ ki ≤ 50
* 0 ≤ wi, j ≤ 50
* 0 ≤ pi, j ≤ 300
* 0 ≤ fi <s
Input
The input consists of multiple test cases. Given on a blank line delimiter. One test case is given in the following format. The end of input is indicated by EOF.
s d m
k1
w1,1 p1,1 w1,2 p1,2 ... w1,k p1, k
k2
w2,1 p2,1 w2,2 p2,2 ... w2,k p2, k
...
ks
ws, 1 ps, 1 ws, 2 ps, 2 ... ws, k ps, k
f1 f2 ... fd
here,
* s: Sweetness set type
* d: Target period
* m: Budget
* ki: Number of types of sweets included in the i-th sweetness set
* Wi, j: Effect of jth sweetness in ith sweetness set on body weight
* pi, j: The price of the j-th sweetness included in the i-th sweetness set
* fi: Number of sweetness set sold on day i (starting from 0)
Is.
Output
For each test case, print the maximum impact on your weight within your budget and the minimum amount required to do so on a single line, separated by blanks.
Example
Input
3 3 100
2
5 20 3 10
2
10 50 12 60
2
8 30 22 100
0 1 2
1 1 30
1
13 8
0
Output
23 100
13 8
|
#include <bits/stdc++.h>
using namespace std;
#define MAX 334
typedef pair<int, int> pii;
int main()
{
int s, d, m;
while (cin >> s >> d >> m) {
vector<pii> v[s];
for (int i = 0; i < s; i++) {
int k, w, p;
cin >> k;
for (int j = 0; j < k; j++) {
cin >> w >> p;
v[i].push_back(pii(w, p));
}
}
int dp[MAX], f;
memset(dp, -1, sizeof(dp));
dp[m] = 0;
for (int i = 0; i < d; i++) {
cin >> f;
for (int j = 0; j < (int)v[f].size(); j++) {
for (int k = 0; k <= m; k++) {
if (dp[k] == -1) continue;
int nm = k - v[f][j].second;
if (nm >= 0) {
dp[nm] = max(dp[nm], dp[k] + v[f][j].first);
}
}
}
}
int idx = m;
for (int i = m-1; i >= 0; i--) {
if (dp[i] > dp[idx]) {
idx = i;
}
}
cout << dp[idx] << " " << m - idx << endl;
}
return 0;
}
|
The fact that any positive integer has a representation as the sum of at most four positive squares (i.e. squares of positive integers) is known as Lagrange’s Four-Square Theorem. The first published proof of the theorem was given by Joseph-Louis Lagrange in 1770. Your mission however is not to explain the original proof nor to discover a new proof but to show that the theorem holds for some specific numbers by counting how many such possible representations there are.
For a given positive integer n, you should report the number of all representations of n as the sum of at most four positive squares. The order of addition does not matter, e.g. you should consider 42 + 32 and 32 + 42 are the same representation.
For example, let’s check the case of 25. This integer has just three representations 12 +22 +22 +42 , 32 + 42 , and 52 . Thus you should report 3 in this case. Be careful not to count 42 + 32 and 32 + 42 separately.
Input
The input is composed of at most 255 lines, each containing a single positive integer less than 215 , followed by a line containing a single zero. The last line is not a part of the input data.
Output
The output should be composed of lines, each containing a single integer. No other characters should appear in the output.
The output integer corresponding to the input integer n is the number of all representations of n as the sum of at most four positive squares.
Example
Input
1
25
2003
211
20007
0
Output
1
3
48
7
738
|
#include <iostream>
#include <cmath>
using std::cin;
using std::cout;
using std::endl;
int dfs(int n, int sum, int k, int sn) {
int ret = 0;
if ( k < 0 ) {
return 0;
}
else {
if (sn == sum) {
return 1;
}
}
if (sn > sum || n == 0) {
return 0;
}
if ( sn + (k * pow(n,2)) < sum ) {
return 0;
}
ret += dfs(n, sum, k-1, sn+pow(n,2));
ret += dfs(n-1, sum, k, sn);
return ret;
}
int main(void) {
int n;
cin >> n;
int lim,ret;
bool find = false;
while ( n != 0 ) {
find = false;
for (int i = 1; !(find); i++) {
if ( !(pow(i,2) < n) ) {
lim = i;
find = true;
}
}
ret = dfs(lim, n, 4, 0);
cout << ret << endl;
cin >> n;
}
return 0;
}
|
Example
Input
Alice Bob
3
2
Alice Bob
Bob Clare
2
Bob Clare
Clare David
2
Clare David
David Alice
Output
No
|
#include<cstdio>
#include<vector>
#include<map>
#include<cstring>
#include<string>
#include<iostream>
using namespace std;
map<string,int>myhash;
int hashclock=0;
int g[2000][310][310];
vector<int>fg[310][310];
bool visit[2000];
int n;
int getnu(){
string tss;
cin>>tss;
if(myhash.count(tss))
return myhash[tss];
hashclock++;
myhash[tss]=hashclock;
return hashclock;
}
void floyd(int i){
for(int j=1;j<=hashclock;j++)
for(int a=1;a<=hashclock;a++)
for(int b=1;b<=hashclock;b++)
if((g[i][a][j]!=0)&&(g[i][j][b]!=0))
g[i][a][b]=1;
}
bool getans(){
int x,y;
x=getnu();
y=getnu();
scanf("%d",&n);
for(int i=1;i<=n;i++){
int m;
scanf("%d",&m);
for(int j=1;j<=m;j++){
int a=getnu(),b=getnu();
g[i][a][b]=1;
fg[a][b].push_back(i);
}
}
bool flag=1;
g[0][x][y]=1;
while(flag){
flag=0;
for(int i=1;i<=hashclock;i++)
for(int j=1;j<=hashclock;j++)
if(g[0][i][j]){
for(vector<int>::iterator it=fg[i][j].begin();it!=fg[i][j].end();it++)
if(visit[*it]==false){
for(int a=1;a<=hashclock;a++)
for(int b=1;b<=hashclock;b++)
if(g[*it][a][b])
g[0][a][b]=1;
visit[*it]=true;
flag=1;
}
}
floyd(0);
}
for(int i=1;i<=hashclock;i++)
for(int j=1;j<=hashclock;j++)
if((g[0][i][j]!=0)&&(g[0][j][i]!=0)){
//cout<<i<<endl<<j<<endl;
return 0;
}
return 1;
}
int main(){
//freopen("in2.txt","r+",stdin);
if(getans()){
printf("Yes\n");
}
else{
printf("No\n");
}
return 0;
}
|
Problem
There is a dial-type padlock. This Nanjing lock has five dials and an enter button.
Rotate the five dials to create a five-digit integer in hexadecimal, press the enter button to enter it, and if the entered value and password match, it will open. For each of the five dials
0,1,2,3,4,5,6,7,8,9, a, b, c, d, e, f, 0,1,2,3,4,5,6,7,8, 9,a, b, c, d, e, f, 0,1,2, ...
It is written so that the characters appear in the order of.
The owner has forgotten the password. However, I remember that out of the five digits of the password, only one digit was even and the other four were odd. However, even numbers are 0,2,4,6,8, a, c, e, and odd numbers are 1,3,5,7,9, b, d, f.
It is also known that this key is defective and will open even if you enter a number different from the password under the following conditions. Originally, the key cannot be opened unless the entered integer and password match for all five digits. However, if the even-numbered digits of the password are the i-digits, the i-digits will match even if the odd numbers before and after the even-numbered numbers are entered when determining the match of the i-digits. It will be misjudged.
For example, if the password is a padlock of "57677", there are odd numbers of '5' and '7' before and after '6', so even if you enter "57577" or "57777" in addition to "57677" It will open. Similarly, if the password is a padlock with "130bd", when you enter "13fbd" or "131bd" in addition to "130bd" because there are odd numbers of "1" and "f" before and after "0". But it opens.
We now know that there are N password candidates, one of which is the correct password. The owner decided to enter an integer many times and keep trying until the key was unlocked. The owner wants to press the enter button as few times as possible.
How many times do you have to press the enter button when the owner takes the best strategy? Print that number. Also, output the set of integers to be input when it actually reaches the maximum in ascending order. If the answer is not uniquely determined, output the smallest one in lexicographical order.
Constraints
* 1 ≤ N ≤ 6000
* passwordi ≠ passwordj (i <j)
* The string consists of 5 numbers from 0 to 9 or lowercase letters a to f, one of which is even and the other four are odd.
Input
The input is given in the following format.
N
password1
password2
...
passwordN
N is given on the first line.
The string passwordi, which represents a 5-digit hexadecimal number representing a password candidate, is given to the i-th line from the second line to the N + 1 line.
Output
Output the maximum number of times the enter button is pressed when the optimal strategy is taken before the key is unlocked on one line. Then, output the set of integers to be input at the maximum in ascending order. If the answer is not unique, output the smallest one in lexicographical order.
Examples
Input
1
0111f
Output
1
0111f
Input
3
57567
57587
0d351
Output
2
0d351
57577
Input
6
1811b
1a11b
f3b1e
f3b1c
b0df3
bedf3
Output
3
1911b
bfdf3
f3b1d
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
//BEGIN CUT HERE
template<typename T,bool directed>
struct Dinic{
struct edge {
int to;
T cap;
int rev;
edge(){}
edge(int to,T cap,int rev):to(to),cap(cap),rev(rev){}
};
vector<vector<edge> > G;
vector<int> level,iter;
Dinic(){}
Dinic(int n):G(n),level(n),iter(n){}
int add_edge(int from,int to,T cap){
G[from].emplace_back(to,cap,G[to].size());
G[to].emplace_back(from,directed?0:cap,G[from].size()-1);
return G[to].back().rev;
}
void bfs(int s){
fill(level.begin(),level.end(),-1);
queue<int> que;
level[s]=0;
que.emplace(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.emplace(e.to);
}
}
}
}
T dfs(int v,int t,T 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]){
T d=dfs(e.to,t,min(f,e.cap));
if(d==0) continue;
e.cap-=d;
G[e.to][e.rev].cap+=d;
return d;
}
}
return 0;
}
T flow(int s,int t,T lim){
T fl=0;
while(1){
bfs(s);
if(level[t]<0||lim==0) break;
fill(iter.begin(),iter.end(),0);
while(1){
T f=dfs(s,t,lim);
if(f==0) break;
fl+=f;
lim-=f;
}
}
return fl;
}
T flow(int s,int t){
return flow(s,t,numeric_limits<T>::max()/2);
}
T cut(int s,int t,int x,int a){
static_assert(directed, "must be directed");
auto &e=G[x][a];
int y=e.to;
T ce=e.cap,cr=G[y][e.rev].cap;
if(cr==0) return 0;
e.cap=G[y][e.rev].cap=0;
T cap=cr-flow(x,y,cr);
if(x!=s&&cap!=0) flow(x,s,cap);
if(t!=y&&cap!=0) flow(t,y,cap);
e.cap=ce+cr;
return cap;
}
};
//END CUT HERE
template<typename T>
vector<T> compress(vector<T> v){
sort(v.begin(),v.end());
v.erase(unique(v.begin(),v.end()),v.end());
return v;
}
template<typename T>
map<T, int> dict(const vector<T> &v){
map<T, int> res;
for(int i=0;i<(int)v.size();i++)
res[v[i]]=i;
return res;
}
//INSERT ABOVE HERE
signed GRL_6_A(){
cin.tie(0);
ios::sync_with_stdio(0);
int V,E;
cin>>V>>E;
Dinic<int, true> dinic(V);
for(int i=0;i<E;i++){
int u,v,c;
cin>>u>>v>>c;
dinic.add_edge(u,v,c);
}
cout<<dinic.flow(0,V-1)<<endl;
return 0;
}
/*
verified on 2019/06/10
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_6_A&lang=jp
*/
signed SPOJ_FASTFLOW(){
cin.tie(0);
ios::sync_with_stdio(0);
Int n,m;
cin>>n>>m;
Dinic<Int, false> G(n);
for(Int i=0;i<m;i++){
Int a,b,c;
cin>>a>>b>>c;
if(a==b) continue;
a--;b--;
G.add_edge(a,b,c);
}
cout<<G.flow(0,n-1)<<endl;
return 0;
}
/*
verified on 2019/06/10
https://www.spoj.com/problems/FASTFLOW/
*/
signed SPOJ_BANKROB(){
cin.tie(0);
ios::sync_with_stdio(0);
int n,m,s,t;
cin>>n>>m>>s>>t;
s--;t--;
const int INF=5050;
Dinic<int, true> G(n*2);
for(int i=0;i<m;i++){
int x,y;
cin>>x>>y;
x--;y--;
G.add_edge(n+x,y,INF);
G.add_edge(n+y,x,INF);
}
for(int i=0;i<n;i++)
G.add_edge(i,n+i,1);
cout<<G.flow(n+s,t)<<endl;
return 0;
}
/*
verified on 2019/06/10
https://www.spoj.com/problems/BANKROB/
*/
signed AOJ_1599(){
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin>>n;
vector<string> es(n);
for(int i=0;i<n;i++) cin>>es[i];
const int L=5;
vector<string> vs;
for(string &s:es){
for(char &c:s){
if(isdigit(c)) c=c-'0';
else c=c-'a'+10;
}
for(int i=0;i<L;i++){
if(s[i]&1) continue;
s[i]=(s[i]+1)%16;
vs.emplace_back(s);
s[i]=(s[i]+15)%16;
s[i]=(s[i]+15)%16;
vs.emplace_back(s);
s[i]=(s[i]+1)%16;
}
}
es=compress(es);
vs=compress(vs);
auto vd=dict(vs);
auto restore=
[](string s){
for(char &c:s){
if(c>=10) c='a'+(c-10);
else c='0'+c;
}
return s;
};
int m=vd.size();
Dinic<int, true> G(m+2);
int S=m,T=m+1;
vector<int> used(m,0);
using P = pair<int, int>;
map<string, P> mp;
for(string &s:es){
for(int i=0;i<L;i++){
if(s[i]&1) continue;
s[i]=(s[i]+1)%16;
int x=vd[s];
s[i]=(s[i]+15)%16;
s[i]=(s[i]+15)%16;
int y=vd[s];
s[i]=(s[i]+1)%16;
int sum=0;
for(char c:vs[x]) sum+=c/2;
if(sum&1) swap(x,y);
mp[s]=P(x,G.add_edge(x,y,1));
if(!used[x]){
mp[vs[x]]=P(S,G.add_edge(S,x,1));
used[x]=1;
}
if(!used[y]){
mp[vs[y]]=P(y,G.add_edge(y,T,1));
used[y]=1;
}
}
}
vector<string> as;
for(auto s:es) as.emplace_back(s);
for(auto s:vs) as.emplace_back(s);
sort(as.begin(),as.end());
cout<<G.flow(S,T)<<"\n";
for(auto s:as){
int x=mp[s].first;
int a=mp[s].second;
if(G.cut(S,T,x,a)==1){
G.G[x][a].cap=0;
cout<<restore(s)<<"\n";
}
}
cout<<flush;
return 0;
}
/*
verified on 2019/06/18
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1599
*/
signed main(){
//GRL_6_A();
//SPOJ_FASTFLOW();
//SPOJ_BANKROB();
AOJ_1599();
return 0;
}
|
There is a group that paints an emblem on the ground to invite aliens every year. You are a member of this group and you have to paint the emblem this year.
The shape of the emblem is described as follows. It is made of n regular triangles whose sides are equally one unit length long. These triangles are placed so that their centroids coincide, and each of them is rotated counterclockwise by 360/n degrees with respect to the one over it around its centroid. The direction of the top triangle is not taken into account.
It is believed that emblems have more impact as their n are taken larger. So you want to paint the emblem of n as large as possible, but you don’t have so much chemicals to paint. Your task is to write a program which outputs the area of the emblem for given n so that you can estimate the amount of the needed chemicals.
<image>
Figure 1: The Emblem for n = 2
Input
The input data is made of a number of data sets. Each data set is made of one line which contains an integer n between 1 and 1000 inclusive.
The input is terminated by a line with n = 0. This line should not be processed.
Output
For each data set, output the area of the emblem on one line. Your program may output an arbitrary number of digits after the decimal point. However, the error should be 10-6 ( = 0.000001) or less.
Example
Input
1
2
3
4
5
6
0
Output
0.433013
0.577350
0.433013
0.732051
0.776798
0.577350
|
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <climits>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include <bitset>
#include <stack>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef pair<int,int> pii;
const int INF = 1<<29;
const double PI = acos(-1);
const double EPS = 1e-8;
int main() {
int n;
while(cin >> n, n) {
double t;
if (n % 3 == 0) t = PI/n;
else t = PI/3/n;
double s = 1.0/(sqrt(3)+1/tan(t))/6;
double ans = s*2*n*(n%3?3:1);
printf("%.10f\n", ans);
}
}
|
The rabbit, who successfully defeated the ambushed enemy, succeeded in advancing the hero into the enemy's castle. When the hero released the cats trapped in the castle dungeon, some of them were the hero's. It will help me.
According to the cats, to reach the Demon King in the back of the castle, you will have to go through n rooms from 1 to n in this order, but one enemy is waiting in each room and you will defeat them one by one. For each of the m cats that became friends, the winning rate against each enemy in each room is known, and the main character dispatches these cats one by one to the back of the castle. Each room Can only pass after defeating the enemy there, so if one cat is killed by an enemy in one room, the next cat will fight from the enemy in that room.
The dispatched cat will proceed until it is killed by the enemy, but each time you know which room the dispatched cat was killed by the enemy, you can decide which cat to dispatch next. For example, will the cats have the greatest chance of defeating all the enemies awaiting them?
Input
The first line of input is given with m and n separated by spaces. 1 ≤ m, n ≤ 16
The next m line is given n real numbers that represent the probability that the cat will beat the enemy. The jth real number in the i + 1st line represents the probability that the cat will beat the enemy in room j. Is up to 3 digits after the decimal point.
Output
Answer the probability when you decide the order so that the cats have the maximum probability of defeating all the enemies waiting for them. The output may contain errors, but the error from the true value is 10-9. Within.
Example
Input
2 3
0.900 0.500 0.100
0.500 0.500 0.500
Output
0.372500000000
|
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
int m,n;
double dp[17][(1<<16) + 1];
double prob[17][17];
double calc(int f, int s) {
if (f == n) return 1.0;
if (dp[f][s] != -1.0) return dp[f][s];
double ret = 0;
for (int k=0; k<m; ++k) if (!(s & (1<<k))) { // ???????????????????????????
double cp = 1.0;
double sum = 0;
for (int j=f; j<n && cp > 0.0; ++j) { // ?????????????????¢
if (prob[k][j] < 1.0) {
sum += calc(j, s|(1<<k)) * cp * (1.0 - prob[k][j]);
}
cp *= prob[k][j];
}
// ???????????§???????¶????????¢????(????????§?¢????0????????£?????????????????§??§??????
sum += cp;
ret = max(ret, sum);
}
//printf("f:%d\ts:%d\tp:%f\tret:%f\n",f,s,p,ret);
return dp[f][s] = ret;
}
int main() {
cin >> m >> n;
for (int i=0; i<m; ++i) {
for (int j=0; j<n; ++j) {
cin >> prob[i][j];
}
}
// init
for (int i=0; i<17; ++i) for (int j=0; j<(1<<16)+1; ++j) dp[i][j] = -1.0;
printf("%.12f\n", calc(0, 0));
return 0;
}
|
F: Transparent mahjong tiles
You will play mahjong against Mr. Takanosu, a gambler who is rumored to have fallen into the darkness. Mr. Takanosu has been rumored to be a natural disaster, so he has proposed a game using a bizarre mahjong tile called Takanosu tile.
Mahjong is a game in which players hold multiple tiles called hand tiles, and their hand tiles are no longer more than their opponents, and the victory is confirmed by making them into the shape of an agari. On the front side of the mahjong tile, what the tile is is drawn, and on the back side of the tile, nothing is drawn. Therefore, when you play mahjong, you should face the front side of your Tehai to your side and the back side to the player's side. This way, only you can know what your Tehai is. The real thrill of mahjong is that players read each other's arrangements and enjoy it.
However, Takanosu tiles are transparent mahjong tiles. Since the Takanosu tiles are transparent, players can know each other's hand tiles. With this, you cannot enjoy reading the arrangements.
"This is no longer a mahjong tile." If you are not convinced to use the mahjong tiles, as a result of twists and turns with Mr. Takanashi, you will play a mixture of mahjong tiles and ordinary mahjong tiles. It was.
As a starting point, you decide to predict what Takanosu's Tehai tiles are. Mr. Takanosu's hand tiles consist of Takanosu tiles and ordinary tiles. For the sake of simplicity, the Takanosu tiles and ordinary tiles shall consist of 4 tiles of 12 types from 1 to 12.
For a hand tile consisting of 3n + 2 tiles, the hand tile is agari when the following three conditions are met.
* There is one set of tiles that combines the same numbers
* The remaining 3n tiles are n groups of 3 number combinations.
* Each group is either a combination of three identical numbers or a combination of three consecutive numbers.
For example
1 1 1 3 3 3 5 5 5 7 7 7 8 9
All 14 tiles like this are made up of Takanosu tiles. In this case, one combination of two tiles and four groups can be made as follows, which is Agari.
(1 1 1) (3 3 3) (5 5 5) (7 7) (7 8 9)
Next, we will give an example of a hand tile that is a mixture of ordinary tiles and Takanosu tiles.
1 1 1 3 3 3 5 5 5 7 7 7 * *
14 tiles like this are composed of 12 Takanosu tiles and 2 ordinary tiles (*). In this case, two ordinary tiles may be 8 and 9, so one combination of two tiles and four groups can be made, which may be agari.
(1 1 1) (3 3 3) (5 5 5) (7 7) (7 [8] [9])
For the same example, two ordinary tiles may be 8 and 8 as follows, so it may be an agari of the form:
(1 1 1) (3 3 3) (5 5 5) (7 7 7) ([8] [8])
However, since the same tile of 7 can only be used up to 4 tiles, it is not an agari of the following shape.
(1 1 1) (3 3 3) (5 5 5) (7 7 7) ([7] [7])
When Mr. Takanashi's 3n + 1 hand tile is given as an input, consider adding one tile to Mr. Takanashi's hand tile to make 3n + 2 hand tiles. At this time, find all the additional tiles (Agari tiles) that can turn 3n + 2 hand tiles into Agari.
Input
The input is given in the following format.
n
Tile 1 Tile 2 ... Tile 3n + 1
The input data satisfies the following conditions, and n satisfies 0 <= n <= 15. Each tile is a Takanosu tile or an ordinary tile. In the case of Takanosu tiles, it is represented by an integer of 1 or more and 12 or less, and in the case of ordinary tiles, it is represented by the character *.
Output
Output the list of tiles in ascending order. Output a line break each time you output one tile. If you don't have a tile, display -1 on one line.
Sample Input 1
Four
1 1 1 3 3 3 5 5 5 7 7 7 9
Sample Output 1
8
9
Sample Input 2
Four
1 2 2 3 3 4 5 6 7 8 8 8 9
Sample Output 2
1
Four
7
9
Ten
Sample Input 3
Four
1 1 1 4 4 4 7 7 7 8 8 9 *
Sample Output 3
6
7
8
9
Ten
11
Sample Input 4
Four
1 * * * * * * * * * * * *
Sample Output 4
1
2
3
Four
Five
6
7
8
9
Ten
11
12
Sample Input 5
1
3 * 1 4
Sample Output 5
1
2
Four
Five
Example
Input
4
1 1 1 3 3 3 5 5 5 7 7 7 9
Output
8
9
|
#include<cstdio>
#include<cstring>
#include<algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int n,star;
int cnt[12]; // 数字 i が書かれた牌はあと i 個
int rem[12]; // * が i に成れるのは rem[i] 個まで
bool dfs(int i){
if(i==12) return star==0;
if(cnt[i]==0){
if(dfs(i+1)) return true;
}
// i, i, i
if(cnt[i]+min(star,rem[i])>=3){
int tmp=min(cnt[i],3);
cnt[i]-=tmp;
star-=3-tmp;
rem[i]-=3-tmp;
bool res=dfs(i);
cnt[i]+=tmp;
star+=3-tmp;
rem[i]+=3-tmp;
if(res) return true;
}
// i, i+1, i+2
if(i<=9){
bool b=true; // i, i+1, i+2 の割り当てが可能かどうか
int minus=0;
rep(j,3){
if(cnt[i+j]==0 && min(star-minus,rem[i+j])==0) b=false;
if(cnt[i+j]==0) minus++;
}
if(b){
bool used[3]={};
rep(j,3){
if(cnt[i+j]>0) cnt[i+j]--, used[j]=true;
else star--, rem[i+j]--;
}
bool res=dfs(i);
rep(j,3){
if(used[j]) cnt[i+j]++;
else star++, rem[i+j]++;
}
if(res) return true;
}
}
return false;
}
int main(){
scanf("%d",&n);
int hai[47],star=0;
rep(i,3*n+1){
char s[4]; scanf("%s",s);
if(s[0]=='*'){
hai[i]=-1;
star++;
}
else{
hai[i]=atoi(s)-1;
cnt[hai[i]]++;
}
}
bool none=true;
rep(a,12) if(cnt[a]<4) { // 3*n+2 枚目の牌
hai[3*n+1]=a;
cnt[a]++;
rep(i,12) rem[i]=4-cnt[i];
bool ok=false;
rep(b,12) if(cnt[b]+star>=2) { // 最後の二つの牌
int tmp1[47],tmp2[12],tmp3[12];
memcpy(tmp1,hai,sizeof hai);
memcpy(tmp2,cnt,sizeof cnt);
memcpy(tmp3,rem,sizeof rem);
::star=star;
int m=3*n+2,two=2;
rep(i,m) if(two>0 && hai[i]== b) swap(hai[i],hai[m-1]), i--, m--, two--, cnt[b]--;
rep(i,m) if(two>0 && hai[i]==-1) swap(hai[i],hai[m-1]), i--, m--, two--, rem[b]--, ::star--;
ok=dfs(0);
memcpy(hai,tmp1,sizeof hai);
memcpy(cnt,tmp2,sizeof cnt);
memcpy(rem,tmp3,sizeof rem);
if(ok) break;
}
if(ok) printf("%d\n",a+1), none=false;
cnt[a]--;
}
if(none) puts("-1");
return 0;
}
|
F --Dangerous Delivery
Story
Person D had a serious mission. It is to deliver the next DAtaCoDer Regular Contest (DARC) D problem to Mr. Dhokudai, the president of DAtaCoDer. N cities are lined up in a straight line from city 1 where D's hideout is located to city N where the DAtaCoDer headquarters is located. During this move, a group of green triangles plotting injustice are aiming for the D problem, and they must protect the D problem from their devil's hands.
Fortunately, D's person has the ability to move across dimensional walls, so it's not easy to get caught. However, this movement method has some drawbacks. First of all, there is a gap when you start moving, and when you find that moment, you will find yourself at the destination. The green triangles continue to monitor each of them overlooking multiple cities. Moreover, reading the movement of the person in D, it seems that he is gradually moving in the direction of city N. Therefore, traveling from a city monitored by many green triangles or traveling a long distance increases the risk of discovery. The second drawback is that moving across a dimensional wall puts a strain on the body and can only be used once a day. It is also necessary to consider the pace distribution so that it will be in time for D days after the next DARC is held. It is unlikely that D's person will be captured like a green triangle, but the cautious D's person sought to minimize the risk of moving from City 1 to City N by D days later.
Problem
There are N cities on a two-dimensional plane. Cities 1 to N are aligned from left to right, and city i is in position (p_i, 0). Satisfy p_i <p_ {i + 1} (1 \ leq i <N).
In addition, there are M enemies on this two-dimensional plane, and the enemy j is initially in the position (a_j, b_j). Enemy j is watching the range of 45 ° up and down in the left direction. That is, all cities included in the area above the straight line y = x-a_j + b_j and below the straight line y = -x + a_j + b_j are in sight. Also, all enemies move to the right by exactly X every day. That is, the position of the enemy j on the dth day is (a_j + X (d-1), b_j).
Here, the degree of surveillance w_ {d, i} of the city i on the d day is defined by the total number of enemies who have the city i in sight on the d day. At this time, the movement from city i to city k on day d bears the risk of w_ {d, i} \ times | p_i-p_k |. If you can only move once a day, minimize the total risk of moving from city 1 to city N by D days later.
Input
The input consists of the following format.
N M D X
p_1 p_2 ... p_N
a_1 b_1
...
a_M b_M
The first line consists of four integers, and the number of cities N, the number of enemies M, the upper limit D of the number of days that can be moved, and the movement distance X of enemies per day are given, each separated by one blank character. The second line consists of N integers, and the i-th integer is given the x-coordinate p_i of the position of the city i, separated by a single character. The following M line is given the position information of the enemy. The second line of j + (1 \ leq j \ leq M) consists of two integers, and the x-coordinate a_j and y-coordinate b_j of the position of the enemy j on the first day are given by separating them with one blank character.
Constraints:
* 1 \ leq N \ leq 10 ^ 4
* 1 \ leq M \ leq 10 ^ 4
* 1 \ leq D \ leq 10 ^ 2
* 1 \ leq X \ leq 10 ^ 6
* 0 \ leq p_i, a_j \ leq 10 ^ 6, -10 ^ 6 \ leq b_j \ leq 10 ^ 6
* p_i <p_ {i + 1}
Output
Output the minimum sum of risks for being in city N by day D on one line. Be sure to start a new line at the end of the line.
Sample Input 1
3 2 2 1
0 3 6
1 1
3 -2
Sample Output 1
6
DangerousDelivery_sample1-1.png DangerousDelivery_sample1-2.png
On the first day, city 1 is monitored by 2 people, city 2 by 0 people, and city 3 by 0 people. Similarly, on the second day, city 1 is monitored by 2 people, city 2 by 0 people, and city 3 by 0 people. Therefore, on the first day, moving from city 1 to city 2 has a risk of 2 \ times | 3-0 | = 6, and on the second day, moving from city 2 to city 3 has a risk of 0 \ times | 6-3. The total of 6 of | = 0 is the minimum.
Sample Input 2
3 2 2 1
0 3 6
twenty one
3 -1
Sample Output 2
9
DangerousDelivery_sample2-1.png DangerousDelivery_sample2-2.png
The method of movement is the same as the first sample, but on the second day, the cost changes to 1 \ times | 6-3 | = 3 because the number of guards in city 2 increases by 1 due to the movement of the enemy. Therefore, the minimum risk is 9.
Sample Input 3
10 8 5 3
0 8 10 13 17 20 21 29 30 45
18 2
50 -20
17 1
38 21
40 -11
0 0
0 0
22 -1
Sample Output 3
222
Example
Input
3 2 2 1
0 3 6
1 1
3 -2
Output
6
|
// * template
#include <bits/stdc++.h>
#ifdef LOCAL
#include "dump.hpp"
#else
#define dump(...)
#endif
using namespace std;
template<class T> inline void chmax(T &a, const T &b) { if(a < b) a = b; }
template<class T> inline void chmin(T &a, const T &b) { if(a > b) a = b; }
template<class T, class U> inline void fill_array(T &e, const U &v) { e = v; }
template<class T, class U, size_t s> inline void fill_array(T (&a)[s], const U &v) {for(auto&e:a)fill_array(e,v);}
template<class T, class U, size_t s> inline void fill_array(array<T, s> &a, const U &v) {for(auto&e:a)fill_array(e,v);}
template<class T, class U> inline void fill_array(vector<T> &a, const U &v) {for(auto&e:a)fill_array(e,v);}
struct range {
typedef int Int;
struct iter {
Int i;
const Int s;
iter(const Int &i_, const Int &s_):i(i_), s(s_) {}
bool operator!=(const iter &r) const { return s > 0 ? i < r.i : i > r.i; }
const Int &operator*() const { return i; }
iter &operator++() { i += s; return *this; }
};
const Int f, l, s;
range(const Int &f_, const Int &l_, const Int &s_):f(f_), l(l_), s(s_) {}
range(const Int &f_, const Int &l_):f(f_), l(l_), s(1) {}
range(const Int &num):f(0), l(num), s(1) {}
iter begin() const { return iter(f, s); }
iter end() const { return iter(l, s); }
};
// * solve
class BIT {
private:
int size;
vector<int> bit;
public:
BIT(int n = 0):size(n), bit(n + 1, 0) {}
void add(int i, int x) {
++i;
while(i <= size) {
bit[i] += x;
i += i & -i;
}
}
int sum(int i) const {
++i;
int s = 0;
while(i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
};
struct line {
typedef long long Int;
Int a, b;
line(Int a_, Int b_):a(a_), b(b_) {}
Int operator()(Int x) const {
return a * x + b;
}
};
inline bool check(const line &f1, const line &f2, const line &f3) {
return (f2.a - f1.a) * (f3.b - f2.b) >= (f2.b - f1.b) * (f3.a - f2.a);
}
constexpr int MAX_X = 1e6;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m, day, speed;
cin >> n >> m >> day >> speed;
vector<int> pos(n);
for(auto &e : pos) cin >> e;
BIT bit(MAX_X + 2);
bit.add(0, m);
vector<int> enemy(m);
for(auto &e : enemy) {
int a, b;
cin >> a >> b;
e = a - abs(b);
bit.add(max(e + 1, 0), -1);
}
vector<long long> dp(n, 1e12);
dp[0] = 0;
const auto make_f = [&](int i) { const long long w = bit.sum(pos[i]); return line(w, dp[i] - w * pos[i]); };
for(const int d : range(day)) {
vector<long long> next_dp(dp);
deque<line> deq{make_f(0)};
for(const int i : range(1, n)) {
const int &p = pos[i];
while(deq.size() > 1 && deq[0](p) >= deq[1](p)) deq.pop_front();
chmin(next_dp[i], deq.front()(p));
const auto f = make_f(i);
while(deq.size() > 1 && check(deq[deq.size() - 2], deq.back(), f)) deq.pop_back();
deq.emplace_back(move(f));
}
dp = move(next_dp);
dump(dp);
for(auto &e : enemy) {
bit.add(max(e + 1, 0), 1);
e = min(e + speed, MAX_X + 1);
bit.add(max(e + 1, 0), -1);
}
}
cout << dp.back() << endl;
return EXIT_SUCCESS;
}
|
Example
Input
200 500 800 500
3
400 0
450 500
400 1000
3
600 0
550 500
600 1000
Output
100 600
|
#include<bits/stdc++.h>
#define MAX 30
#define inf 1<<29
#define linf 1e16
#define eps (1e-8)
#define Eps (1e-15)
#define mod 1000000007
#define pi acos(-1)
#define phi (1.0+sqrt(5))/2.0
#define f first
#define s second
#define mp make_pair
#define pb push_back
#define all(a) (a).begin(),(a).end()
#define pd(a) printf("%.10f\n",(double)(a))
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define RFOR(i,a,b) for(int i=(a)-1;(b)<=i;i--)
#define equals(a,b) (fabs((a)-(b))<eps)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<int,double> pid;
typedef pair<double,int> pdi;
typedef pair<double,double> pdd;
typedef vector<int> vi;
typedef vector<pii> vpi;
const int dx[8]={1,0,-1,0,1,1,-1,-1};
const int dy[8]={0,1,0,-1,1,-1,1,-1};
class Point{
public:
double x,y;
Point(double x=0,double y=0):x(x),y(y){}
Point operator+(Point p){ return Point(x+p.x,y+p.y);}
Point operator-(Point p){ return Point(x-p.x,y-p.y);}
Point operator*(double k){ return Point(x*k,y*k);}
Point operator/(double k){ return Point(x/k,y/k);}
bool operator<(Point p)const{ return equals(x,p.x) ? y-p.y<-eps : x-p.x<-eps; }
bool operator==(Point p)const{ return fabs(x-p.x)<eps && fabs(y-p.y)<eps;}
double abs(){ return sqrt(norm());}
double norm(){ return (x*x+y*y);}
};
typedef Point Vector;
typedef vector<Point> Polygon;
class Segment{
public:
Point p1,p2;
Segment(Point p1=Point(),Point p2=Point()):p1(p1),p2(p2){}
};
typedef Segment Line;
double norm(Vector a){ return (a.x*a.x+a.y*a.y);}
double abs(Vector a){ return sqrt(norm(a));}
double dot(Vector a,Vector b){ return (a.x*b.x+a.y*b.y);}
double cross(Vector a,Vector b){ return (a.x*b.y-a.y*b.x);}
Point project(Segment s,Point p){
Vector base=(s.p2-s.p1);
double r=(dot(p-s.p1,base)/base.norm());
return (s.p1+base*r);
}
bool isParallel(Vector a,Vector b){
return equals(cross(a,b),0.0);
}
bool isParallel(Segment s,Segment t){
return equals(cross(s.p1-s.p2,t.p1-t.p2),0.0);
}
int ccw(Point p0,Point p1,Point p2){
Vector a=p1-p0;
Vector b=p2-p0;
if(cross(a,b)>eps)return 1;
if(cross(a,b)<-eps)return -1;
if(dot(a,b)<-eps)return 2;
if(a.norm()<b.norm())return -2;
return 0;
}
bool intersect(Point p1,Point p2,Point p3,Point p4){
return (ccw(p1,p2,p3)*ccw(p1,p2,p4)<=0 &&
ccw(p3,p4,p1)*ccw(p3,p4,p2)<=0);
}
bool intersect(Segment s1,Segment s2){
return intersect(s1.p1,s1.p2,s2.p1,s2.p2);
}
Point getCrossPointLL(Line a,Line b){
double A=cross(a.p2-a.p1,b.p2-b.p1);
double B=cross(a.p2-a.p1,a.p2-b.p1);
if(abs(A)<eps || abs(B)<eps)return b.p1;
return b.p1+(b.p2-b.p1)*(B/A);
}
int contains(Polygon g,Point p){
int n=g.size();
bool x=false;
for(int i=0;i<n;i++){
Vector a=g[i]-p,b=g[(i+1)%n]-p;
if(abs(cross(a,b))<eps && dot(a,b)<eps)return 1;
if(a.y>b.y)swap(a,b);
if(a.y<eps && eps<b.y && cross(a,b)>eps)x=!x;
}
if(x)return 2;
return 0;
}
bool contains(Polygon p,Segment s){
vector<pair<double,Point> > v;
int n=p.size();
v.push_back(make_pair(0,s.p1));
v.push_back(make_pair(abs(s.p1-s.p2),s.p2));
for(int i=0;i<n;i++){
Segment e(p[i],p[(i+1)%n]);
if(isParallel(s,e))continue;
if(!intersect(s,e))continue;
Point m=getCrossPointLL(s,e);
v.push_back(make_pair(abs(m-s.p1),m));
}
sort(v.begin(),v.end());
for(int i=0;i<v.size()-1;i++){
Point m=v[i].s+(v[i+1].s-v[i].s)/2.0;
if(contains(p,m)==0)return false;
}
return true;
}
pair<Point,Point> closest_pair(Segment a,Segment b){
pair<Point,Point> res(a.p1,b.p1);
if(abs(a.p1-b.p2)<abs(res.f-res.s))res=mp(a.p1,b.p2);
if(abs(a.p2-b.p1)<abs(res.f-res.s))res=mp(a.p2,b.p1);
if(abs(a.p2-b.p2)<abs(res.f-res.s))res=mp(a.p2,b.p2);
Point c;
c=project(b,a.p1);
if(ccw(b.p1,b.p2,c)==0 &&
abs(c-a.p1)<abs(res.f-res.s))res=mp(a.p1,c);
c=project(b,a.p2);
if(ccw(b.p1,b.p2,c)==0 &&
abs(c-a.p2)<abs(res.f-res.s))res=mp(a.p2,c);
c=project(a,b.p1);
if(ccw(a.p1,a.p2,c)==0 &&
abs(c-b.p1)<abs(res.f-res.s))res=mp(b.p1,c);
c=project(a,b.p2);
if(ccw(a.p1,a.p2,c)==0 &&
abs(c-b.p2)<abs(res.f-res.s))res=mp(b.p2,c);
return res;
}
int n,m;
Point s,t;
vector<Point> w,e;
Polygon W,E,WE;
vector<Point> vp[2];
vector<pid> g[2][MAX];
void add_edge(int ind,int to,int from,double cost){
g[ind][to].pb(mp(from,cost));
g[ind][from].pb(mp(to,cost));
}
double dijkstra(Point a){
int ind=-1;
Polygon p;
if(contains(W,a)){ ind=0;p=W; }
else { ind=1;p=E; }
int start=vp[ind].size();
g[ind][start].clear();
FOR(i,0,vp[ind].size())
if(contains(p,Segment(vp[ind][i],a)))
g[ind][start].pb(mp(i,abs(a-vp[ind][i])));
double d[MAX];
priority_queue<pdi,vector<pdi>,greater<pdi> > pq;
fill(d,d+MAX,inf);
d[start]=0;
pq.push(mp(0,start));
while(pq.size()){
pdi u=pq.top();
pq.pop();
if(d[u.s]<u.f)continue;
if(u.s==0)return d[u.s];
FOR(i,0,g[ind][u.s].size()){
int next=g[ind][u.s][i].f;
double cost=g[ind][u.s][i].s+d[u.s];
if(cost<d[next]){
d[next]=cost;
pq.push(mp(cost,next));
}
}
}
return inf;
}
void make_graphs(){
W.pb(Point(0,1000));
W.pb(Point(0,0));
FOR(i,0,n)W.pb(w[i]);
E.pb(Point(1000,0));
E.pb(Point(1000,1000));
RFOR(i,m,0)E.pb(e[i]);
vp[0].pb(s);
FOR(i,0,W.size())vp[0].pb(W[i]);
FOR(i,0,vp[0].size()){
FOR(j,i+1,vp[0].size()){
if(contains(W,Segment(vp[0][i],vp[0][j])))
add_edge(0,i,j,abs(vp[0][i]-vp[0][j]));
}
}
vp[1].pb(t);
FOR(i,0,E.size())vp[1].pb(E[i]);
FOR(i,0,vp[1].size()){
FOR(j,i+1,vp[1].size()){
if(contains(E,Segment(vp[1][i],vp[1][j])))
add_edge(1,i,j,abs(vp[1][i]-vp[1][j]));
}
}
}
pdd check(Segment a,Segment b){
pdd res(inf,inf);
if(isParallel(a,b)){
Segment seg=a;
Point c;
bool flag=false;
c=project(a,b.p1);
if(ccw(seg.p1,seg.p2,c)==0){ seg.p1=c;flag=true; }
c=project(a,b.p2);
if(ccw(seg.p1,seg.p2,c)==0){ seg.p2=c;flag=true; }
if(flag){
Vector v=seg.p2-seg.p1;
v=v/abs(v);
double L=0,R=abs(seg.p1-seg.p2);
FOR(k,0,100){
double m1=(L*phi+R)/(1.0+phi);
double m2=(L+R*phi)/(1.0+phi);
Point p1,p2;
p1=seg.p1+v*m1;
p2=project(b,p1);
double res1=dijkstra(p1)+dijkstra(p2);
p1=seg.p1+v*m2;
p2=project(b,p1);
double res2=dijkstra(p1)+dijkstra(p2);
if(res1<res2)R=m2;
else L=m1;
}
Point p1=seg.p1+v*L,p2=project(b,p1);
res.f=abs(p1-p2);
res.s=dijkstra(seg.p1+v*L)+dijkstra(project(b,seg.p1+v*L));
return res;
}
}
pair<Point,Point> pp=closest_pair(a,b);
res.f=abs(pp.f-pp.s);
res.s=dijkstra(pp.f)+dijkstra(pp.s);
return res;
}
bool comp(pdd a,pdd b){
return fabs((a.f)-(b.f))<Eps ? b.s-a.s<-Eps : b.f-a.f<-Eps;
}
void solve(){
make_graphs();
pdd res(inf,inf);
FOR(i,0,n-1){
Segment s1(w[i],w[i+1]);
FOR(j,0,m-1){
Segment s2(e[j],e[j+1]);
pdd tmp=check(s1,s2);
if(comp(res,tmp))res=tmp;
}
}
printf("%.10f %.10f\n",res.f,res.f+res.s);
}
int main()
{
cin>>s.x>>s.y>>t.x>>t.y;
cin>>n;
w.resize(n);
FOR(i,0,n)cin>>w[i].x>>w[i].y;
cin>>m;
e.resize(m);
FOR(i,0,m)cin>>e[i].x>>e[i].y;
solve();
return 0;
}
|
F： 最短距離を伸ばすえびちゃん (Ebi-chan Lengthens Shortest Paths)
Problem
Ebi-chan loves directed graphs. One day, a directed graph with N vertices and M edges dropped from somewhere in front of Ebi-chan! The vertices and the edges of the graph is labeled with a number from 1 to N and from 1 to M, respectively. Moreover, the ith edge directs from a vertex u_i to a vertex v_i with distance d_i.
Ebi-chan thought that, for a pair of vertices s and t, she tries to lengthen the distance of shortest paths from s to t. Although Ebi-chan should lengthen all edges slightly to easily achieve hers goal, she can not enjoy the directed graph with such way! So, she decided the following rules of operations that can be done by her.
* She can lengthen each edges independently.
* When she lengthens an edge, she must select the additional distance from positive integers.
* The ith edge takes a cost c_i per additional distance 1.
How is the minimum total cost of operations needed to achieve Ebi-chan’s goal?
Input Format
An input is given in the following format.
N M s t
u_1 v_1 d_1 c_1
$\vdots$
u_M v_M d_M c_M
In line 1, four integers N, M, s, and t are given in separating by en spaces. N and M is the number of vertices and edges, respectively. Ebi-chan tries to lengthen shortest paths from the vertex s to the vertex t.
Line 1 + i, where 1 \leq i \leq M, has the information of the ith edge. u_i and v_i are the start and end vertices of the edge, respectively. d_i and c_i represents the original distance and cost of the edge, respectively. These integers are given in separating by en spaces.
Constraints
* 2 \leq N \leq 200
* 1 \leq M \leq 2,000
* 1 \leq s, t \leq N, s \neq t
* 1 \leq u_i, v_i \leq N, u_i \neq v_i (1 \leq i \leq M)
* For each i, j (1 \leq i < j \leq M), u_i \neq u_j or v_i \neq v_j are satisfied.
* 1 \leq d_i \leq 10 (1 \leq i \leq M)
* 1 \leq c_i \leq 10 (1 \leq i \leq M)
* It is guaranteed that there is at least one path from s to t.
Output Format
Print the minimum cost, that is to lengthen the distance of shortest paths from s to t at least 1, in one line.
Example 1
3 3 1 3
1 2 1 1
2 3 1 1
1 3 1 1
Output 1
1
Ebi-chan should lengthen 3rd edge with additional distance 1.
Exapmle 2
8 15 5 7
1 5 2 3
3 8 3 6
8 7 1 3
2 7 6 4
3 7 5 5
8 3 1 3
5 6 3 5
1 7 3 2
4 3 2 4
5 4 4 3
2 3 2 2
2 8 6 5
6 2 1 3
4 2 1 6
6 1 4 2
Output 2
8
Example
Input
Output
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
using namespace std;
const long long int MOD = 1000000007;
long long int N, M, K, H, W, L, R;
class Edge {
public:
long long int to;
long long int max_flow;
long long int rev;
};
class Dinic {
int V;
public:
vector< vector< Edge>> edge;
vector< int > depth;
vector< int > index;
Dinic(int n) {
n++;
V = n;
edge.resize(V);
depth.resize(V);
index.resize(V);
return;
}
void Add_Edge(int l, int r, int max_flow) {
edge[l].push_back({r, max_flow, (int) edge[r].size()});
edge[r].push_back({l, 0, (int) edge[l].size() - 1});
return;
}
void Check_Depth(int s) {
for(int i = 0; i < V; i++) {
depth[i] = INT_MAX;
}
depth[s] = 0;
queue< int > Q;
Q.push(s);
while(!Q.empty()) {
int cn = Q.front();
Q.pop();
for(auto i : edge[cn]) {
if(i.max_flow > 0 && depth[i.to] == INT_MAX) {
depth[i.to] = depth[cn] + 1;
Q.push(i.to);
}
}
}
return;
}
long long int max_flow(int v, int g, long long int ret) {
if(v == g) {
return ret;
}
for(int i = index[v]; i < edge[v].size(); i++) {
if(edge[v][i].max_flow > 0 && depth[v] < depth[edge[v][i].to]) {
long long int d = max_flow(edge[v][i].to, g, min(ret, edge[v][i].max_flow));
if(d > 0) {
edge[v][i].max_flow -= d;
edge[edge[v][i].to][edge[v][i].rev].max_flow += d;
return d;
}
}
}
return 0;
}
long long Solve(int s, int g) {
long long int ret = 0;
while(1) {
Check_Depth(s);
if(depth[g] == INT_MAX) {
return ret;
}
for(int i = 0; i < V; i++) {
index[i] = 0;
}
long long int add = 0;
while((add = max_flow(s, g, INT_MAX)) > 0) {
ret += add;
}
}
return ret;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M >> L >> R;
vector< vector< pair< int, int>> > edge(N + 1, vector< pair< int, int>>(N + 1, {-1, -1}));
for(int i = 0; i < M; i++) {
int a, b, c, d;
cin >> a >> b >> c >> d;
edge[a][b] = {c, d};
}
vector< int > dis(N + 1, MOD);
dis[L] = 0;
priority_queue< pair< int, int >, vector< pair< int, int>>, greater< pair< int, int>> > PQ;
PQ.push({0, L});
while(!PQ.empty()) {
auto box = PQ.top();
PQ.pop();
int cn = box.second;
int c = box.first;
if(dis[cn] < c) {
continue;
}
for(int i = 1; i <= N; i++) {
if(edge[cn][i].first == -1) {
continue;
}
if(dis[i] > c + edge[cn][i].first) {
dis[i] = c + edge[cn][i].first;
PQ.push({dis[i], i});
}
}
}
vector< vector< bool>> flag(N + 1, vector< bool >(N + 1, false));
queue< int > Q;
Q.push(R);
bool v[1000] = {};
while(!Q.empty()) {
int cn = Q.front();
Q.pop();
for(int i = 1; i <= N; i++) {
if(edge[i][cn].first == -1) {
continue;
}
if(dis[cn] - edge[i][cn].first == dis[i]) {
flag[i][cn] = true;
if(v[i]++)continue;
Q.push(i);
}
}
}
Dinic d(N + 2);
d.Add_Edge(0, L, 100000);
d.Add_Edge(R, N + 1, 100000);
for(int i = 1; i <= N; i++) {
for(int j = 1; j <= N; j++) {
if(flag[i][j]) {
d.Add_Edge(i, j, edge[i][j].second);
}
}
}
cout << d.Solve(0, N + 1) << endl;
return 0;
}
|
Problem
There are $ N $ arithmetic progressions with the number of terms $ L $. The first term of the $ i $ arithmetic progression is $ a_i $ and the tolerance is $ d_i $. Arrange the first sequence, the second sequence, ..., the $ N $ sequence in order from the first sequence, and let the resulting sequence be $ A $. Then, when you select an arbitrary interval of length $ K $ from $ A $ and create a new sequence $ B $, maximize the sum of the sequence $ B $.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq L \ leq 10 ^ 5 $
* $ 1 \ leq K \ leq N \ times L $
* $ 0 \ leq a_i \ leq 10 ^ 5 $
* $ 1 \ leq d_i \ leq 10 ^ 3 $
* All inputs are integers
Input
The input is given in the following format.
$ N $ $ L $ $ K $
$ a_1 $ $ d_1 $
$ a_2 $ $ d_2 $
...
$ a_N $ $ d_N $
Three integers $ N $, $ L $, $ K $ are given on the first line, separated by blanks.
In the following $ N $ row, the $ i $ arithmetic progression information $ a_i $, $ d_i $ is given, separated by blanks.
Output
Outputs the maximum value of the sum of the sequence $ B $ on one line.
Examples
Input
3 3 5
0 3
2 2
4 1
Output
25
Input
3 3 5
0 10
8 1
11 1
Output
58
|
#include<bits/stdc++.h>
using namespace std;
#define MAX_N 100005
typedef long long ll;
ll calc(ll a,ll d,ll n){
if(n==0)return 0;
return ( a+a+d*(n-1) )*n/2;
}
ll N,X,L;
ll a[MAX_N],d[MAX_N];
ll solve2();
ll solve(){
ll res=0, val=0;
int j=0;
for(int i=0;i<N;i++){
while( j < i+L/X ){
val+=(a[j]+a[j]+(X-1)*d[j])*X/2;
j++;
if(j>=N)break;
}
res=max(res,val);
if(j>=N)break;
ll aj =a[j]+(L%X)*d[j];
double A = -0.5*d[i] + 0.5*d[j];
double B = -(a[i]-0.5*d[i]) + (aj-0.5*d[j]);
double left=0, right =X-L%X , ll , rr, lv,rv;
for(int p=0;p<100;p++){
ll=(left+left+right)/3.0;
rr=(right+right+left)/3.0;
lv=A*ll*ll+B*ll;
rv=A*rr*rr+B*rr;
if(lv < rv)left=ll;
else right=rr;
}
res=max(res, val + calc(a[j],d[j],L%X) );
res=max(res, val + calc(a[j],d[j],X) - calc(a[i],d[i],X-L%X) );
long long mm = left;
/*
cout<<"i="<<i<<" j="<<j<<endl;
cout<<"val="<<val<<endl;
cout<<"mm="<<mm<<endl;
cout<<val + calc(a[j],d[j],L%X)<<endl;
cout<<endl;
*/
for( long long dm = mm-1; dm<=mm+1; dm++ ){
if(dm<0 || dm>(X-L%X) )continue;
res=max(res, val + calc(a[j],d[j],L%X+dm) - calc(a[i],d[i],dm) );
}
if(i>0 && L%X>0){
long long fa = a[i-1]+(X-1)*d[i-1];
long long fd = d[i-1]*-1;
long long sa = a[j]+(L%X-1)*d[j];
long long sd = d[j]*-1;
A = ( fd*fd*0.5 ) - ( sd*sd*0.5 );
B = ( fa-fd*0.5 ) - ( sa-sd*0.5 );
left=0,right=L%X;
for(int p=0;p<100;p++){
ll=(left+left+right)/3.0;
rr=(right+right+left)/3.0;
lv=A*ll*ll+B*ll;
rv=A*rr*rr+B*rr;
if(lv < rv)left=ll;
else right=rr;
}
mm = left;
for( long long dm = mm-1; dm<=mm+1; dm++ ){
if(dm<0 || dm>(L%X) )continue;
res=max(res, val + calc(a[j],d[j],L%X) + calc(fa,fd,dm) - calc(sa,sd,dm) );
}
}
val-=(a[i]+a[i]+(X-1)*d[i])*X/2;
}
return res;
}
int main(){
scanf("%lld %lld %lld",&N,&X,&L);
for(int i=0;i<N;i++){
scanf("%lld %lld",&a[i],&d[i]);
}
ll ans=solve();
for(int i=0;i<N;i++){
a[i]= a[i]+d[i]*(X-1);
d[i]*=-1;
}
printf("%lld\n",ans);
return 0;
}
ll solve2(){
ll res=0;
for(int i=0;i<N;i++){
ll A = a[i] + (X-1)*d[i];
ll B = a[i] + (X-L)*d[i];
ll sum = (A+B)*L/2;
res=max(res,sum);
}
return res;
}
|
You can obtain profits from foreign exchange margin transactions. For example, if you buy 1000 dollar at a rate of 100 yen per dollar, and sell them at a rate of 108 yen per dollar, you can obtain (108 - 100) × 1000 = 8000 yen.
Write a program which reads values of a currency $R_t$ at a certain time $t$ ($t = 0, 1, 2, ... n-1$), and reports the maximum value of $R_j - R_i$ where $j > i$ .
Constraints
* $2 \leq n \leq 200,000$
* $1 \leq R_t \leq 10^9$
Input
The first line contains an integer $n$. In the following $n$ lines, $R_t$ ($t = 0, 1, 2, ... n-1$) are given in order.
Output
Print the maximum value in a line.
Examples
Input
6
5
3
1
3
4
3
Output
3
Input
3
4
3
2
Output
-1
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int N;
int main(){
cin >> N;
ll mini;
cin >> mini;
ll res = -1000000000000LL;
for(int i=1;i<N;i++){
int a; cin >> a;
res = max( res, a-mini );
mini = min( mini, (ll)a );
}
cout << res << endl;
}
|
In programming languages like C/C++, a goto statement provides an unconditional jump from the "goto" to a labeled statement. For example, a statement "goto CHECK_NUM;" is executed, control of the program jumps to CHECK_NUM. Using these constructs, you can implement, for example, loops.
Note that use of goto statement is highly discouraged, because it is difficult to trace the control flow of a program which includes goto.
Write a program which does precisely the same thing as the following program (this example is wrtten in C++). Let's try to write the program without goto statements.
void call(int n){
int i = 1;
CHECK_NUM:
int x = i;
if ( x % 3 == 0 ){
cout << " " << i;
goto END_CHECK_NUM;
}
INCLUDE3:
if ( x % 10 == 3 ){
cout << " " << i;
goto END_CHECK_NUM;
}
x /= 10;
if ( x ) goto INCLUDE3;
END_CHECK_NUM:
if ( ++i <= n ) goto CHECK_NUM;
cout << endl;
}
Constraints
* 3 ≤ n ≤ 10000
Input
An integer n is given in a line.
Output
Print the output result of the above program for given integer n.
Example
Input
30
Output
3 6 9 12 13 15 18 21 23 24 27 30
|
#include<stdio.h>
int main(){
int x;
scanf("%d",&x);
for(int a=1;a<=x;a++){
if(a%3==0){
printf(" %d",a);
}
else{
int b=a;
while(b>0){
if(b%10==3){
printf(" %d",a);
break;
}
b=b/10;
}
}
}
printf("\n");
return 0;
}
|
How many ways are there to place a black and a white knight on an N * M chessboard such that they do not attack each other? The knights have to be placed on different squares. A knight can move two squares horizontally and one square vertically, or two squares vertically and one square horizontally. The knights attack each other if one can reach the other in one move.
Input :
The first line contains the number of test cases T. Each of the next T lines contains two integers N and M.
Output :
Output T lines, one for each test case, each containing the required answer for the corresponding test case.
Sample Input :
3
2 2
2 3
4 5
Sample Output :
12
26
312
Constraints :
1 <= T <= 10000
1 <= N,M <= 100000
|
#!/usr/bin/python
# coding: utf-8
t=int(raw_input())
for i in range(t):
n,m=raw_input().split(' ')
n=int(n)
m=int(m)
if(n>1 and m>1):
ans=((n*m) * (n*m-1)) - (4*((n-1)*(m-2) + (n-2)*(m-1))) #nm*nm -9nm +12m +12n -16
else:
if(n==1):
ans=m*(m-1)
else:
ans=n*(n-1)
print ans
'''
How many ways are there to place a black and a white knight on an N * M chessboard such that they do not attack each other? The knights have to be placed on different squares. A knight can move two squares horizontally and one square vertically, or two squares vertically and one square horizontally. The knights attack each other if one can reach the other in one move.
Input :
The first line contains the number of test cases T. Each of the next T lines contains two integers N and M.
Output :
Output T lines, one for each test case, each containing the required answer for the corresponding test case.
Sample Input :
3
2 2
2 3
4 5
Sample Output :
12
26
312
Constraints :
1 <= T <= 10000
1 <= N,M <= 100000
'''
|
As you might know, cooking is the process of taking a food item and subjecting it to various processes(like heating, roasting, baking etc).
A food item gets prepared after it has been subjected to exactly N processes.
The order in which the processes are applied matters(heating and then baking is different from baking and then heating). Also, the same processes cannot be aplied twice in succession. For example, heating → baking → heating is allowed, but heating → heating → baking is not allowed because 'heating' comes twice in succession.
Any given sequence A1, A2, A3, ... AN of N processes can be used to cook a food item if and only if Ai ≠ Ai+1 for all 1 ≤ i ≤ N-1.
The chefs kitchen has got K equipments for K different processes.
Chef has to cook two dishes in parallel.
This means that if the first dish is prepared by applying processes A1, A2, A3, ... AN in this order, and the second dish made by processes B1, B2, B3, ... BN, then Ai ≠ Bi for any 1 ≤ i ≤ N, because otherwise chef would need two equipments for the process Ai.
Needless to say, 1 ≤ Ai, Bi ≤ K, no two consecutive elements of A are same, and no two consecutive elements of B are same.
Given N, K your task is to find the number of ways in which in which he can prepare the two dishes. Since the number of ways can be very huge, you have to report it modulo 1000000007.
Input Description
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
Each test case is described by line containing two space separated integers, N and K as per the problem description.
Output Description
For each Test case, output a separate line containing the answer modulo 1000000007.
Sample Input
3
2 2
2 3
1 3
Sample Output
2
18
6
Explanation
For first test case, there are two ways:
a) A = {1, 2} and B = {2, 1} and b) A = {2, 1} and B = {1,2}.
For third test case, A and B are of length 1. A0 can take three different values and for each value of A0, B0 can take any of the other two values.
Constraints
T ≤ 100
1 ≤ N, K ≤ 10^9
Subtask 1 (30 points):
N, K ≤ 5
Subtask 2 (20 points):
N, K ≤ 10000
the answer(without taking modulo 1000000007) will be at most 10^4.
Subtask 3 (25 points):
N, K ≤ 10000
Subtask 4 (25 points):
No special constraints
|
from sys import stdin
MOD = 1000000007
for trial in xrange(int(stdin.readline())):
N,K = map(int,stdin.readline().split())
Kmod = K%MOD
K1mod=(K-1)%MOD
K2mod=(K-2)%MOD
if K==1: print 0
elif K==2: print 2
else:
inner = ((Kmod*K1mod*K1mod)%MOD + (Kmod*K1mod*K2mod*K2mod)%MOD)%MOD
if N==1: print (K*(K-1))%MOD
elif N==2: print inner
else: print ((inner)*pow(K**2-3*K+3,N-2,MOD))%MOD
|
Problem Statement
Chef studies combinatorics. He tries to group objects by their rang (a positive integer associated with each object). He also gives the formula for calculating the number of different objects with rang N as following:
the number of different objects with rang N = F(N) = A0 + A1 * N + A2 * N^2 + A3 * N^3.
Now Chef wants to know how many different multisets of these objects exist such that sum of rangs of the objects in the multiset equals to S. You are given the coefficients in F(N) and the target sum S. Please, find the number of different multisets modulo 1,000,000,007.
You should consider a multiset as an unordered sequence of integers. Two multisets are different if and only if there at least exists one element which occurs X times in the first multiset but Y times in the second one, where (X ≠ Y).
Input
The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows.
The first line of each test case contains four integers A0, A1, A2, A3. The second line contains an integer S.
Output
For each test case, output a single line containing a single integer - the answer to the test case modulo 1,000,000,007.
Constraints
1 ≤ T ≤ 500
1 ≤ S ≤ 100
0 ≤ Ai ≤ 1000
Sum of all S for all test cases is not greater than 500. It's guaranteed that at least one Ai is non-zero.
Example
Input:
4
1 0 0 0
1
1 0 0 0
3
0 1 0 0
2
2 3 1 4
10
Output:
1
3
3
213986343
Explanation
Example case 2.
In the second example function looks as follows F(N) = 1. So for each rang there is a single object of the rang. To get multiset with sum of rangs equal to 3, you can pick: three objects of rang 1, or one object of rang 1 and one of rang 2, or only one object of rang 3.
Example case 3.
In the third example function looks as follows F(N) = N. So, you have one distinct object of rang 1, two distinct objects of rang 2, three distinct objects of rang 3 and so on. To get
multiset with sum of rangs equal to 2, you can pick: two objects of rang 1, one of objects of rang 2 (two ways).
|
mod = 1000000007
comb_cache = {}
def combinations(n, r):
if r < (n // 2): r = n - r
if (n, r) in comb_cache: return comb_cache[(n, r)]
comb = 1
for i in xrange(r + 1, n + 1): comb *= i
for i in xrange(2, n - r + 1): comb /= i
comb_cache[(n, r)] = comb % mod
return comb
F_cache = {}
A0, A1, A2, A3 = (0, 0, 0, 0)
def F(N):
if N not in F_cache:
F_cache[N] = (((A3 * N + A2) * N + A1) * N + A0) % mod
return F_cache[N]
meal = {}
def cook(N, S):
if S == 0: return 1
if N == 0: return 0
if (N, S) in meal: return meal[(N, S)]
food = 0
for rank in xrange(N, 0, -1):
for count in xrange(S // rank, 0, -1):
cooked = cook(rank - 1, S - (rank * count))
if cooked: food += combinations(F(rank) + count - 1, count) * cooked
food %= mod
meal[(N, S)] = food
return food
for _ in xrange(int(raw_input())):
A0, A1, A2, A3 = map(int, raw_input().split())
S = int(raw_input())
F_cache = {}
meal = {}
print cook(S, S)
|
Okay. Before we begin, a hint : This one's taken from somewhere. Word to word. Google comes to mind, doesn't it? Here goes:
For the heck of it, we define a new sequence as the infinite sequence of all integers, in ascending order, that can represented as any positive integer power of 5 (i.e 5k where k is a positive integer) or as a sum of distinct positive integer powers of 5 (i.e 5a1 + 5a2 + 5a3 + ... , where a1, a2, a3, ... are distinct positive integers). All the numbers in the lucky sequence are called lucky numbers. The first few numbers are 5, 25, 30, 125, 130, 150, ... Given n your task is to find the nth number in the sequence.
Input
First line of input contains an integer t, t ≤ 200, representing the number of test- cases. Then t lines follow each containing one integer n, 1 ≤ n ≤ 8000.
Output
For each test case output the "Case#x" followed by nth number on a separate line. Answers will fit in a 32-bit signed integer.
Sample
Input
4
1
2
3
9
Output
5
25
30
630
|
# imports
import sys
import StringIO
import math
class Problem(object):
def __init__(self, reader):
self.reader = reader
def run(self):
test_cases = int(self.reader.readline().strip())
for test_case in range(test_cases):
lucky_number = 0
number = int(self.reader.readline().strip())
binary = bin(number)
try:
binary_num = binary[2:]
except:
binary_num= test_case
binary_len = len(binary_num)
for idx, char in enumerate(binary_num):
if char == '1' :
lucky_number = lucky_number + math.pow(5, binary_len - idx)
print int(lucky_number)
# Main entry point
############################################################
if __name__ == "__main__":
data = sys.stdin
problem = Problem(data)
problem.run()
|
Tuzik and his master Vanka are playing some unusual game. Initially there are two stacks of nuts. The first stack contains A nuts and the second contains B nuts. A player's move consists of two steps:
Choose one stack and eat it.
Split the other stack into two new stacks. If a player can't split it he loses (if stack contains only 1 nut).
Tuzik starts the game. Tell who wins if both players play optimally.
Input
The first line of the input contains an integer T, denoting the number of test cases. The following T lines each contain 2 space-separated integers - A and B - for this test case.
Output
For each test case, output a single line containing the word "Tuzik" or "Vanka" (without quotes) depending on the winner in this test case.
Constraints
1 ≤ T ≤ 1000
1 ≤ A, B ≤ 10^4
Example
Input:
2
1 1
1 2
Output:
Vanka
Tuzik
Explanation
In the first test case Tuzik can't finish even the first move, so Vanka wins.
In the second test case Tuzik eats the first stack (with 1 nut), then splits the second stack (with 2 nuts) into two stacks, and Vanka loses.
|
T = int(raw_input())
while T > 0:
a = raw_input()
a = a.split(' ')
A = int(a[0])
B = int(a[1])
if A%2 !=0 and B%2 !=0:
print "Vanka"
else:
print 'Tuzik'
T = T - 1
|
Given n sticks' lengths, determine whether there is a solution to choose 2k out of them and use these 2k sticks to form two k-convex polygons (non-degenerated), namely, two convex polygons each has exactly k sticks as its sides, and every adjacent sticks are not parallel.
Input
The first line contains two space-separated integers n and k, denoting the number of sticks and the size of convex polygon we needed.
The second line contains n positive integers, denoting the lengths of sticks.
Output
Print "Yes" (without quotes) in the first line if exists a solution. Otherwise print "No" (without quotes) instead.
If such solution exists, you should output a plan in the second line. Print 2k indexes (indexes start from 1) of the sticks you chosen. First k sticks compose the first k-convex polygon. And the later k sticks form the second. If there are more than one solution, output any.
Constraints
2k ≤ n ≤ 1000
3 ≤ k ≤ 10
1 ≤ length of each stick ≤ 10^9
Example
Input 1:
6 3
1 1 1 2 2 2
Output 1:
Yes
1 2 3 4 5 6
Input 2:
6 3
1 2 3 100 200 300
Output 2:
No
Explanation
Example case 1: 1 1 1 and 2 2 2 form two triangles.
Example case 2: Please be careful that convex polygons must be non-degenerated.
|
from itertools import combinations
from collections import defaultdict
def small_j(sticks, cum, k):
for j in range(k - 1, len(sticks)):
i = j - k + 1
hyp = sticks[j]
rest = cum[j - 1] - cum[i] + sticks[i]
if rest > hyp:
return i, j
return None, None
def small_ii(sticks, cum, k):
for jj in range(-1, k - len(sticks) - 1, -1):
ii = jj - k + 1
hyp = sticks[jj]
rest = cum[jj - 1] - cum[ii] + sticks[ii]
if rest > hyp:
return len(sticks) + ii, len(sticks) + jj
assert False
def solve(n, k, sticks):
len_pos = defaultdict(list)
for pos, len_ in enumerate(sticks):
len_pos[len_].append(str(pos + 1))
sticks.sort()
tot = 0
cum = []
for s in sticks:
tot += s
cum.append(tot)
i, j = small_j(sticks, cum, k)
if j is None:
return "No"
ii, jj = small_ii(sticks, cum, k)
if ii > j:
ans = sticks[i:j+1] + sticks[ii:jj+1]
ans_i = []
for len_ in ans:
ans_i.append(len_pos[len_].pop())
return "Yes\n" + " ".join(ans_i)
if jj < 2*k - 1:
return "No"
chosen_sticks = list(enumerate(sticks[jj - 2*k + 1: jj+1]))
assert len(chosen_sticks) == 2*k
positions = range(len(chosen_sticks))
solution = None
for poly1 in combinations(positions, r=k):
poly1 = list(poly1)
i1 = 0
sum1 = 0
sum2 = 0
hyp1 = 0
hyp2 = 0
for pos, cs in chosen_sticks:
if i1 < k and pos == poly1[i1]:
sum1 += cs
i1 += 1
hyp1 = cs
else:
sum2 += cs
hyp2 = cs
sum1 -= hyp1
sum2 -= hyp2
if sum1 > hyp1 and sum2 > hyp2:
solution = poly1
break
if solution is None:
return "No"
else:
chosen_sticks = [v for _, v in chosen_sticks]
poly1 = [chosen_sticks[i] for i in solution]
for v in poly1:
chosen_sticks.remove(v)
poly2 = chosen_sticks
ans = poly1 + poly2
ans_i = []
for len_ in ans:
ans_i.append(len_pos[len_].pop())
return "Yes\n" + " ".join(ans_i)
n, k = map(int, raw_input().split())
sticks = map(int, raw_input().split())
print solve(n, k, sticks)
|
Innopolis University scientists continue to investigate the periodic table. There are n·m known elements and they form a periodic table: a rectangle with n rows and m columns. Each element can be described by its coordinates (r, c) (1 ≤ r ≤ n, 1 ≤ c ≤ m) in the table.
Recently scientists discovered that for every four different elements in this table that form a rectangle with sides parallel to the sides of the table, if they have samples of three of the four elements, they can produce a sample of the fourth element using nuclear fusion. So if we have elements in positions (r1, c1), (r1, c2), (r2, c1), where r1 ≠ r2 and c1 ≠ c2, then we can produce element (r2, c2).
<image>
Samples used in fusion are not wasted and can be used again in future fusions. Newly crafted elements also can be used in future fusions.
Innopolis University scientists already have samples of q elements. They want to obtain samples of all n·m elements. To achieve that, they will purchase some samples from other laboratories and then produce all remaining elements using an arbitrary number of nuclear fusions in some order. Help them to find the minimal number of elements they need to purchase.
Input
The first line contains three integers n, m, q (1 ≤ n, m ≤ 200 000; 0 ≤ q ≤ min(n·m, 200 000)), the chemical table dimensions and the number of elements scientists already have.
The following q lines contain two integers ri, ci (1 ≤ ri ≤ n, 1 ≤ ci ≤ m), each describes an element that scientists already have. All elements in the input are different.
Output
Print the minimal number of elements to be purchased.
Examples
Input
2 2 3
1 2
2 2
2 1
Output
0
Input
1 5 3
1 3
1 1
1 5
Output
2
Input
4 3 6
1 2
1 3
2 2
2 3
3 1
3 3
Output
1
Note
For each example you have a picture which illustrates it.
The first picture for each example describes the initial set of element samples available. Black crosses represent elements available in the lab initially.
The second picture describes how remaining samples can be obtained. Red dashed circles denote elements that should be purchased from other labs (the optimal solution should minimize the number of red circles). Blue dashed circles are elements that can be produced with nuclear fusion. They are numbered in order in which they can be produced.
Test 1
We can use nuclear fusion and get the element from three other samples, so we don't need to purchase anything.
<image>
Test 2
We cannot use any nuclear fusion at all as there is only one row, so we have to purchase all missing elements.
<image>
Test 3
There are several possible solutions. One of them is illustrated below.
Note that after purchasing one element marked as red it's still not possible to immidiately produce the middle element in the bottom row (marked as 4). So we produce the element in the left-top corner first (marked as 1), and then use it in future fusions.
<image>
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, nn;
int fa[400100];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
int ans;
void unionn(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
fa[x] = y;
nn--;
}
int main() {
int i, a, b;
for (i = 1; i <= 400000; i++) fa[i] = i;
scanf("%d%d%d", &n, &m, &q);
nn = n + m;
for (i = 1; i <= q; i++) {
scanf("%d%d", &a, &b);
unionn(a, b + n);
}
printf("%d", nn - 1);
return 0;
}
|
Find out if it is possible to partition the first n positive integers into two non-empty disjoint sets S_1 and S_2 such that:
gcd(sum(S_1), sum(S_2)) > 1
Here sum(S) denotes the sum of all elements present in set S and gcd means the[greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Every integer number from 1 to n should be present in exactly one of S_1 or S_2.
Input
The only line of the input contains a single integer n (1 ≤ n ≤ 45 000)
Output
If such partition doesn't exist, print "No" (quotes for clarity).
Otherwise, print "Yes" (quotes for clarity), followed by two lines, describing S_1 and S_2 respectively.
Each set description starts with the set size, followed by the elements of the set in any order. Each set must be non-empty.
If there are multiple possible partitions — print any of them.
Examples
Input
1
Output
No
Input
3
Output
Yes
1 2
2 1 3
Note
In the first example, there is no way to partition a single number into two non-empty sets, hence the answer is "No".
In the second example, the sums of the sets are 2 and 4 respectively. The gcd(2, 4) = 2 > 1, hence that is one of the possible answers.
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> let(26, 0);
int main() {
long long n;
cin >> n;
if (n <= 2) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
cout << n - 1 << " ";
for (int i = 0; i < n - 1; i++) {
cout << i + 1 << " ";
}
cout << endl << 1 << " " << n << endl;
}
return 0;
}
|
Consider a tree T (that is, a connected graph without cycles) with n vertices labelled 1 through n. We start the following process with T: while T has more than one vertex, do the following:
* choose a random edge of T equiprobably;
* shrink the chosen edge: if the edge was connecting vertices v and u, erase both v and u and create a new vertex adjacent to all vertices previously adjacent to either v or u. The new vertex is labelled either v or u equiprobably.
At the end of the process, T consists of a single vertex labelled with one of the numbers 1, …, n. For each of the numbers, what is the probability of this number becoming the label of the final vertex?
Input
The first line contains a single integer n (1 ≤ n ≤ 50).
The following n - 1 lines describe the tree edges. Each of these lines contains two integers u_i, v_i — labels of vertices connected by the respective edge (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i). It is guaranteed that the given graph is a tree.
Output
Print n floating numbers — the desired probabilities for labels 1, …, n respectively. All numbers should be correct up to 10^{-6} relative or absolute precision.
Examples
Input
4
1 2
1 3
1 4
Output
0.1250000000
0.2916666667
0.2916666667
0.2916666667
Input
7
1 2
1 3
2 4
2 5
3 6
3 7
Output
0.0850694444
0.0664062500
0.0664062500
0.1955295139
0.1955295139
0.1955295139
0.1955295139
Note
In the first sample, the resulting vertex has label 1 if and only if for all three edges the label 1 survives, hence the probability is 1/2^3 = 1/8. All other labels have equal probability due to symmetry, hence each of them has probability (1 - 1/8) / 3 = 7/24.
|
#include <bits/stdc++.h>
using namespace std;
int head[52], tot, size[52], n;
long double c[52][52], dp[52][52], tmp[52], g[52];
inline int rd() {
int x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f ? -x : x;
}
struct edge {
int n, to;
} e[52 << 1];
inline long double calc(int n, int m) { return c[n][m]; }
inline long double path(int n, int m) { return c[n + m][n]; }
inline void add(int u, int v) {
e[++tot].n = head[u];
e[tot].to = v;
head[u] = tot;
}
void dfs(int u, int fa) {
dp[u][0] = 1;
size[u] = 1;
for (int i = head[u]; i; i = e[i].n)
if (e[i].to != fa) {
int v = e[i].to;
dfs(v, u);
for (int i = 0; i <= size[v]; ++i) {
g[i] = 0;
for (int j = 0; j < i; ++j) g[i] += 0.5 * dp[v][j];
g[i] += (size[v] - i) * dp[v][i];
}
for (int j = 0; j < size[u]; ++j)
for (int k = 0; k <= size[v]; ++k)
tmp[j + k] +=
dp[u][j] * g[k] * path(j, k) * path(size[u] - 1 - j, size[v] - k);
for (int j = 0; j <= size[u] + size[v]; ++j)
dp[u][j] = tmp[j], tmp[j] = 0;
size[u] += size[v];
}
}
int main() {
n = rd();
for (int i = 0; i <= n; ++i) {
c[i][0] = 1;
for (int j = 1; j <= i; ++j) c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
int u, v;
for (int i = 1; i < n; ++i) {
u = rd();
v = rd();
add(u, v);
add(v, u);
}
long double xx = 1;
for (int i = 1; i < n; ++i) xx = xx * i;
for (int i = 1; i <= n; ++i) {
memset(dp, 0, sizeof(dp));
dfs(i, 0);
double x = dp[i][n - 1] / xx;
printf("%.10lf\n", x);
}
return 0;
}
|
Graph constructive problems are back! This time the graph you are asked to build should match the following properties.
The graph is connected if and only if there exists a path between every pair of vertices.
The diameter (aka "longest shortest path") of a connected undirected graph is the maximum number of edges in the shortest path between any pair of its vertices.
The degree of a vertex is the number of edges incident to it.
Given a sequence of n integers a_1, a_2, ..., a_n construct a connected undirected graph of n vertices such that:
* the graph contains no self-loops and no multiple edges;
* the degree d_i of the i-th vertex doesn't exceed a_i (i.e. d_i ≤ a_i);
* the diameter of the graph is maximum possible.
Output the resulting graph or report that no solution exists.
Input
The first line contains a single integer n (3 ≤ n ≤ 500) — the number of vertices in the graph.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n - 1) — the upper limits to vertex degrees.
Output
Print "NO" if no graph can be constructed under the given conditions.
Otherwise print "YES" and the diameter of the resulting graph in the first line.
The second line should contain a single integer m — the number of edges in the resulting graph.
The i-th of the next m lines should contain two integers v_i, u_i (1 ≤ v_i, u_i ≤ n, v_i ≠ u_i) — the description of the i-th edge. The graph should contain no multiple edges — for each pair (x, y) you output, you should output no more pairs (x, y) or (y, x).
Examples
Input
3
2 2 2
Output
YES 2
2
1 2
2 3
Input
5
1 4 1 1 1
Output
YES 2
4
1 2
3 2
4 2
5 2
Input
3
1 1 1
Output
NO
Note
Here are the graphs for the first two example cases. Both have diameter of 2.
<image> d_1 = 1 ≤ a_1 = 2
d_2 = 2 ≤ a_2 = 2
d_3 = 1 ≤ a_3 = 2
<image> d_1 = 1 ≤ a_1 = 1
d_2 = 4 ≤ a_2 = 4
d_3 = 1 ≤ a_3 = 1
d_4 = 1 ≤ a_4 = 1
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
template <class T, class U>
inline void checkmin(T &x, U y) {
if (y < x) x = y;
}
template <class T, class U>
inline void checkmax(T &x, U y) {
if (y > x) x = y;
}
template <class T, class U>
inline bool ifmax(T &x, U y) {
if (y > x) return x = y, true;
return false;
}
template <class T, class U>
inline bool ifmin(T &x, U y) {
if (y < x) return x = y, true;
return false;
}
long long fstpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a);
a = (a * a);
b >>= 1;
}
return res;
}
long long powm(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
void fukof() {}
void problem() {}
const long long mod = 1e9 + 7;
const long long N = 100005;
const long long inf = 1e9;
void solve() {
long long n;
cin >> n;
long long a[n + 1], sum = 0;
for (long long i = 0; i < (n); i++) cin >> a[i + 1], sum += a[i + 1];
if (sum < 2 * n - 2) {
cout << "NO\n";
return;
}
cout << "YES ";
long long cnt2 = 0, cnt1 = 0;
vector<long long> a1, a2;
for (long long i = 0; i < (n); i++) {
if (a[i + 1] > 1)
cnt2++, a2.push_back(i + 1);
else
cnt1++, a1.push_back(i + 1);
}
cout << cnt2 + (cnt1 >= 2 ? 2 : cnt1) - 1 << endl;
cout << n - 1 << endl;
if (cnt2 and cnt1) {
a[a2[0]]--;
a[a1[0]]--;
cnt1--;
cout << a2[0] << " " << a1[0] << endl;
if (cnt1) {
a[a2.size() - 1]--;
a[a1[1]]--;
cnt1--;
cout << a2[a2.size() - 1] << " " << a1[1] << endl;
}
}
for (long long i = 0; i < (a2.size() - 1); i++) {
a[a2[i]]--;
a[a2[i + 1]]--;
cout << a2[i] << " " << a2[i + 1] << endl;
}
long long ptr = 0, ptr2 = a1.size() - 1;
while (cnt1 > 0) {
if (a[a2[ptr]] > 0) {
a[a2[ptr]]--;
a[a1[ptr2]]--;
cout << a2[ptr] << " " << a1[ptr2] << endl;
ptr2--;
cnt1--;
} else
ptr++;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int tc = 1;
while (tc--) {
problem();
fukof();
solve();
}
return 0;
}
|
There are n cities along the road, which can be represented as a straight line. The i-th city is situated at the distance of a_i kilometers from the origin. All cities are situated in the same direction from the origin. There are m trucks travelling from one city to another.
Each truck can be described by 4 integers: starting city s_i, finishing city f_i, fuel consumption c_i and number of possible refuelings r_i. The i-th truck will spend c_i litres of fuel per one kilometer.
When a truck arrives in some city, it can be refueled (but refueling is impossible in the middle of nowhere). The i-th truck can be refueled at most r_i times. Each refueling makes truck's gas-tank full. All trucks start with full gas-tank.
All trucks will have gas-tanks of the same size V litres. You should find minimum possible V such that all trucks can reach their destinations without refueling more times than allowed.
Input
First line contains two integers n and m (2 ≤ n ≤ 400, 1 ≤ m ≤ 250000) — the number of cities and trucks.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9, a_i < a_{i+1}) — positions of cities in the ascending order.
Next m lines contains 4 integers each. The i-th line contains integers s_i, f_i, c_i, r_i (1 ≤ s_i < f_i ≤ n, 1 ≤ c_i ≤ 10^9, 0 ≤ r_i ≤ n) — the description of the i-th truck.
Output
Print the only integer — minimum possible size of gas-tanks V such that all trucks can reach their destinations.
Example
Input
7 6
2 5 7 10 14 15 17
1 3 10 0
1 7 12 7
4 5 13 3
4 7 10 1
4 7 10 1
1 5 11 2
Output
55
Note
Let's look at queries in details:
1. the 1-st truck must arrive at position 7 from 2 without refuelling, so it needs gas-tank of volume at least 50.
2. the 2-nd truck must arrive at position 17 from 2 and can be refueled at any city (if it is on the path between starting point and ending point), so it needs gas-tank of volume at least 48.
3. the 3-rd truck must arrive at position 14 from 10, there is no city between, so it needs gas-tank of volume at least 52.
4. the 4-th truck must arrive at position 17 from 10 and can be refueled only one time: it's optimal to refuel at 5-th city (position 14) so it needs gas-tank of volume at least 40.
5. the 5-th truck has the same description, so it also needs gas-tank of volume at least 40.
6. the 6-th truck must arrive at position 14 from 2 and can be refueled two times: first time in city 2 or 3 and second time in city 4 so it needs gas-tank of volume at least 55.
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const int MAXN = 401;
const int INF = 1e9 + 5;
int city[MAXN], dp[MAXN][MAXN][MAXN];
int main() {
for (int i = 0; i < int(MAXN); i++)
for (int j = 0; j < int(MAXN); j++)
for (int k = 0; k < int(MAXN); k++) dp[i][j][k] = INF;
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < int(n); i++) scanf("%d", &city[i]);
for (int i = 0; i < int(n); i++)
for (int j = int(i); j < int(n); j++) dp[0][i][j] = city[j] - city[i];
for (int k = int(1); k < int(n + 1); k++)
for (int i = 0; i < int(n); i++) {
int ind = i;
for (int j = int(i); j < int(n); j++) {
dp[k][i][j] = max(dp[k - 1][i][ind], city[j] - city[ind]);
while (ind + 1 <= j && max(dp[k - 1][i][ind + 1],
city[j] - city[ind + 1]) < dp[k][i][j]) {
ind++;
dp[k][i][j] =
min(dp[k][i][j], max(dp[k - 1][i][ind], city[j] - city[ind]));
}
}
}
long long rta = 0;
for (int i = 0; i < int(m); i++) {
int s, f, c, r;
scanf("%d %d %d %d", &s, &f, &c, &r);
s--;
f--;
int val = dp[r][s][f];
rta = max(rta, (long long)val * c);
}
printf("%lld", rta);
return 0;
}
|
Little Petya loves looking for numbers' divisors. One day Petya came across the following problem:
You are given n queries in the form "xi yi". For each query Petya should count how many divisors of number xi divide none of the numbers xi - yi, xi - yi + 1, ..., xi - 1. Help him.
Input
The first line contains an integer n (1 ≤ n ≤ 105). Each of the following n lines contain two space-separated integers xi and yi (1 ≤ xi ≤ 105, 0 ≤ yi ≤ i - 1, where i is the query's ordinal number; the numeration starts with 1).
If yi = 0 for the query, then the answer to the query will be the number of divisors of the number xi. In this case you do not need to take the previous numbers x into consideration.
Output
For each query print the answer on a single line: the number of positive integers k such that <image>
Examples
Input
6
4 0
3 1
5 2
6 2
18 4
10000 3
Output
3
1
1
2
2
22
Note
Let's write out the divisors that give answers for the first 5 queries:
1) 1, 2, 4
2) 3
3) 5
4) 2, 6
5) 9, 18
|
import java.util.Arrays;
import java.util.Scanner;
public class PetyaAndDivisors {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] result = new int[n];
int[] divisor = new int[100000+5];
Arrays.fill(divisor, -1);
for (int i = 0; i < n; i++) {
int res = 0;
int x = sc.nextInt();
int y = sc.nextInt();
for(int j = 1; j * j <= x; j++){
if(x % j == 0)
{
if(i - y > divisor[j])
res++;
if(j * j != x && i - y > divisor[x / j])
res++;
divisor[j] = divisor[x / j] = i;
}
}
result[i] = res;
}
for (int i = 0; i < n; i++)
System.out.println(result[i]);
}
}
|
On the math lesson a teacher asked each pupil to come up with his own lucky numbers. As a fan of number theory Peter chose prime numbers. Bob was more original. He said that number t is his lucky number, if it can be represented as:
t = a2 + b2, where a, b are arbitrary positive integers.
Now, the boys decided to find out how many days of the interval [l, r] (l ≤ r) are suitable for pair programming. They decided that the day i (l ≤ i ≤ r) is suitable for pair programming if and only if the number i is lucky for Peter and lucky for Bob at the same time. Help the boys to find the number of such days.
Input
The first line of the input contains integer numbers l, r (1 ≤ l, r ≤ 3·108).
Output
In the only line print the number of days on the segment [l, r], which are lucky for Peter and Bob at the same time.
Examples
Input
3 5
Output
1
Input
6 66
Output
7
|
#include <bits/stdc++.h>
using namespace std;
bitset<300000001> gao;
int l, r;
int main() {
gao.set();
gao[1] = 0;
scanf("%d%d", &l, &r);
for (int i = 3; i * i <= r; i += 2)
if (gao[i]) {
int t = i << 1;
for (int j = i * i; j <= r; j += t) gao[j] = false;
}
int ans = l <= 2 && r > 1;
for (int i = 1 + ((l - 1) / 4 + ((l - 1) % 4 != 0)) * 4; i <= r; i += 4)
ans += gao[i];
printf("%d\n", ans);
}
|
Nauuo is a girl who loves playing cards.
One day she was playing cards but found that the cards were mixed with some empty ones.
There are n cards numbered from 1 to n, and they were mixed with another n empty cards. She piled up the 2n cards and drew n of them. The n cards in Nauuo's hands are given. The remaining n cards in the pile are also given in the order from top to bottom.
In one operation she can choose a card in her hands and play it — put it at the bottom of the pile, then draw the top card from the pile.
Nauuo wants to make the n numbered cards piled up in increasing order (the i-th card in the pile from top to bottom is the card i) as quickly as possible. Can you tell her the minimum number of operations?
Input
The first line contains a single integer n (1≤ n≤ 2⋅ 10^5) — the number of numbered cards.
The second line contains n integers a_1,a_2,…,a_n (0≤ a_i≤ n) — the initial cards in Nauuo's hands. 0 represents an empty card.
The third line contains n integers b_1,b_2,…,b_n (0≤ b_i≤ n) — the initial cards in the pile, given in order from top to bottom. 0 represents an empty card.
It is guaranteed that each number from 1 to n appears exactly once, either in a_{1..n} or b_{1..n}.
Output
The output contains a single integer — the minimum number of operations to make the n numbered cards piled up in increasing order.
Examples
Input
3
0 2 0
3 0 1
Output
2
Input
3
0 2 0
1 0 3
Output
4
Input
11
0 0 0 5 0 0 0 4 0 0 11
9 2 6 0 8 1 7 0 3 0 10
Output
18
Note
Example 1
We can play the card 2 and draw the card 3 in the first operation. After that, we have [0,3,0] in hands and the cards in the pile are [0,1,2] from top to bottom.
Then, we play the card 3 in the second operation. The cards in the pile are [1,2,3], in which the cards are piled up in increasing order.
Example 2
Play an empty card and draw the card 1, then play 1, 2, 3 in order.
|
#include <bits/stdc++.h>
using namespace std;
int a[200005], b[200005];
int fl[200005];
int tm[200005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int j = 1; j <= n; j++)
if (b[j] == 1) {
int nfl = 1;
for (int k = j + 1; k <= n; k++)
if (k - j + 1 != b[k]) nfl = 0;
int ls = 1 + n - j;
for (int i = 1; i <= n; i++) fl[a[i]] = 1;
for (int s = 1; s < j; s++) {
if (!fl[ls + s]) nfl = 0;
fl[b[s]] = 1;
}
if (nfl) {
cout << n - ls << endl;
return 0;
}
}
for (int j = 1; j <= n; j++) tm[a[j]] = 0;
for (int j = 1; j <= n; j++) tm[b[j]] = j;
int ans = 0;
for (int j = 1; j <= n; j++) ans = max(ans, (n + 1 - j) + tm[j]);
printf("%d\n", ans);
return 0;
}
|
Vasya's birthday is approaching and Lena decided to sew a patterned handkerchief to him as a present. Lena chose digits from 0 to n as the pattern. The digits will form a rhombus. The largest digit n should be located in the centre. The digits should decrease as they approach the edges. For example, for n = 5 the handkerchief pattern should look like that:
0
0 1 0
0 1 2 1 0
0 1 2 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 4 5 4 3 2 1 0
0 1 2 3 4 3 2 1 0
0 1 2 3 2 1 0
0 1 2 1 0
0 1 0
0
Your task is to determine the way the handkerchief will look like by the given n.
Input
The first line contains the single integer n (2 ≤ n ≤ 9).
Output
Print a picture for the given n. You should strictly observe the number of spaces before the first digit on each line. Every two adjacent digits in the same line should be separated by exactly one space. There should be no spaces after the last digit at the end of each line.
Examples
Input
2
Output
0
0 1 0
0 1 2 1 0
0 1 0
0
Input
3
Output
0
0 1 0
0 1 2 1 0
0 1 2 3 2 1 0
0 1 2 1 0
0 1 0
0
|
a=int(input())
x=a
w=[]
while a>=0:
b=[]
b.append(a)
for i in range(a):
b.append(str(a-1-i))
b.insert(0,(a-1-i))
b.insert(0,' '*(2*(x-a)))
w.append(b)
w.insert(0,b)
a=a-1
w.pop(x)
for j in w:
xx=str(j)
xxx=xx.replace(',','')
xxxx=xxx.replace("'",'')
print(xxxx[2:-1])
|
You are given a sequence of integers a_1, a_2, ..., a_n. You need to paint elements in colors, so that:
* If we consider any color, all elements of this color must be divisible by the minimal element of this color.
* The number of used colors must be minimized.
For example, it's fine to paint elements [40, 10, 60] in a single color, because they are all divisible by 10. You can use any color an arbitrary amount of times (in particular, it is allowed to use a color only once). The elements painted in one color do not need to be consecutive.
For example, if a=[6, 2, 3, 4, 12] then two colors are required: let's paint 6, 3 and 12 in the first color (6, 3 and 12 are divisible by 3) and paint 2 and 4 in the second color (2 and 4 are divisible by 2). For example, if a=[10, 7, 15] then 3 colors are required (we can simply paint each element in an unique color).
Input
The first line contains an integer n (1 ≤ n ≤ 100), where n is the length of the given sequence.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100). These numbers can contain duplicates.
Output
Print the minimal number of colors to paint all the given numbers in a valid way.
Examples
Input
6
10 2 3 5 4 2
Output
3
Input
4
100 100 100 100
Output
1
Input
8
7 6 5 4 3 2 2 3
Output
4
Note
In the first example, one possible way to paint the elements in 3 colors is:
* paint in the first color the elements: a_1=10 and a_4=5,
* paint in the second color the element a_3=3,
* paint in the third color the elements: a_2=2, a_5=4 and a_6=2.
In the second example, you can use one color to paint all the elements.
In the third example, one possible way to paint the elements in 4 colors is:
* paint in the first color the elements: a_4=4, a_6=2 and a_7=2,
* paint in the second color the elements: a_2=6, a_5=3 and a_8=3,
* paint in the third color the element a_3=5,
* paint in the fourth color the element a_1=7.
|
n=int(input())
arr = list(map(int,input().split()))
elem = {}
arr.sort()
for i in arr:
f=0
for k in elem:
if i%k == 0:
elem[k]+=1
f=1
break
if not f:
elem[i] = 1
print(len(elem))
|
You are given an integer array a_1, a_2, ..., a_n, where a_i represents the number of blocks at the i-th position. It is guaranteed that 1 ≤ a_i ≤ n.
In one operation you can choose a subset of indices of the given array and remove one block in each of these indices. You can't remove a block from a position without blocks.
All subsets that you choose should be different (unique).
You need to remove all blocks in the array using at most n+1 operations. It can be proved that the answer always exists.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^3) — length of the given array.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — numbers of blocks at positions 1, 2, ..., n.
Output
In the first line print an integer op (0 ≤ op ≤ n+1).
In each of the following op lines, print a binary string s of length n. If s_i='0', it means that the position i is not in the chosen subset. Otherwise, s_i should be equal to '1' and the position i is in the chosen subset.
All binary strings should be distinct (unique) and a_i should be equal to the sum of s_i among all chosen binary strings.
If there are multiple possible answers, you can print any.
It can be proved that an answer always exists.
Examples
Input
5
5 5 5 5 5
Output
6
11111
01111
10111
11011
11101
11110
Input
5
5 1 1 1 1
Output
5
11000
10000
10100
10010
10001
Input
5
4 1 5 3 4
Output
5
11111
10111
10101
00111
10100
Note
In the first example, the number of blocks decrease like that:
{ 5,5,5,5,5 } → { 4,4,4,4,4 } → { 4,3,3,3,3 } → { 3,3,2,2,2 } → { 2,2,2,1,1 } → { 1,1,1,1,0 } → { 0,0,0,0,0 }. And we can note that each operation differs from others.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 9;
int n, a[N], ans[N][N], m[N][2], g[N], e;
vector<pair<int, int> > p;
pair<int, int> k;
int solve(int x, int y) { return min(x - 1, y); }
int main() {
cin >> n;
for (int i = 1; i < n + 1; i++) cin >> a[i];
p.push_back(make_pair(1, n + 2));
for (int i = 1; i < n + 1; i++) {
while (p[p.size() - 1].second - p[p.size() - 1].first == 1) p.pop_back();
m[i][0] = p[p.size() - 1].first;
m[i][1] = p[p.size() - 1].second;
e = solve(m[i][1] - m[i][0], a[i]);
a[i] -= e;
for (int j = m[i][0]; j < m[i][0] + e; j++) ans[i][j] = 1;
k = p[p.size() - 1];
p.pop_back();
p.push_back(make_pair(m[i][0], m[i][0] + e));
p.push_back(make_pair(m[i][0] + e, m[i][1]));
}
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n + 2; j++) {
if (a[i] && (j < m[i][0] || j >= m[i][1])) ans[i][j] = 1, a[i]--;
}
}
cout << n + 1 << endl;
for (int i = 1; i < n + 2; i++) {
for (int j = 1; j < n + 1; j++) cout << ans[j][i];
cout << endl;
}
}
|
Doctor prescribed medicine to his patient. The medicine is represented by pills. Each pill consists of a shell and healing powder. The shell consists of two halves; each half has one of four colors — blue, red, white or yellow.
The doctor wants to put 28 pills in a rectangular box 7 × 8 in size. Besides, each pill occupies exactly two neighboring cells and any cell contains exactly one half of a pill. Thus, the result is a four colored picture 7 × 8 in size.
The doctor thinks that a patient will recover sooner if the picture made by the pills will be special. Unfortunately, putting the pills in the box so as to get the required picture is not a very easy task. That's why doctor asks you to help.
Doctor has some amount of pills of each of 10 painting types. They all contain the same medicine, that's why it doesn't matter which 28 of them will be stored inside the box.
Place the pills in the box so that the required picture was formed. If it is impossible to place the pills in the required manner, then place them so that the number of matching colors in all 56 cells in the final arrangement and the doctor's picture were maximum.
Input
First 7 lines contain the doctor's picture. Each line contains 8 characters, each character can be "B", "R", "W" and "Y" that stands for blue, red, white and yellow colors correspondingly.
Next four lines contain 10 numbers that stand for, correspondingly, the number of pills painted:
"BY" "BW" "BR" "BB"
"RY" "RW" "RR"
"WY" "WW"
"YY"
Those numbers lie within range from 0 to 28 inclusively. It is guaranteed that the total number of pills in no less than 28.
Output
Print on the first line the maximal number cells for which the colors match.
Then print 13 lines each containing 15 characters — the pills' position in the optimal arrangement. The intersections of odd lines and odd columns should contain characters "B", "R", "W" and "Y". All other positions should contain characters ".", "-" and "|". Use "-" and "|" to show which halves belong to one pill. See the samples for more clarification.
If there are several possible solutions, print any of them.
Examples
Input
WWWBBWWW
WWWBBWWW
YYWBBWWW
YYWBBWRR
YYWBBWRR
YYWBBWRR
YYWBBWRR
0 0 0 8
0 1 5
1 10
5
Output
53
W.W.W.B.B.W.W.W
|.|.|.|.|.|.|.|
W.W.W.B.B.W.W.W
...............
Y.Y.W.B.B.W.W-W
|.|.|.|.|.|....
Y.Y.W.B.B.W.R.R
............|.|
Y.Y.W.B.B.R.R.R
|.|.|.|.|.|....
Y.Y.W.B.B.W.R.R
............|.|
Y-Y.B-B.B-B.R.R
Input
WWWWWWWW
WBYWRBBY
BRYRBWYY
WWBRYWBB
BWWRWBYW
RBWRBWYY
WWWWWWWW
0 0 0 1
0 0 1
0 1
25
Output
15
W.Y.Y-Y.Y-Y.Y-Y
|.|............
W.Y.Y.Y.Y.B-B.Y
....|.|.|.....|
Y-Y.Y.Y.Y.Y-Y.Y
...............
Y.Y.Y.R.Y.Y.Y-Y
|.|.|.|.|.|....
Y.Y.Y.R.Y.Y.Y.Y
............|.|
Y-Y.Y.Y-Y.Y.Y.Y
....|.....|....
Y-Y.Y.Y-Y.Y.Y-Y
|
//package round93;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeSet;
public class E {
InputStream is;
PrintWriter out;
String INPUT = "BBWWRRYY\r\n" +
"\r\n" +
"WRRYYBBW\r\n" +
"\r\n" +
"WYBBWWRW\r\n" +
"\r\n" +
"BYWRRYRY\r\n" +
"\r\n" +
"BRWBBYBY\r\n" +
"\r\n" +
"WRYYWWBR\r\n" +
"\r\n" +
"WBBRRYYR\r\n" +
"\r\n" +
"0 0 0 7\r\n" +
"\r\n" +
"0 0 7\r\n" +
"\r\n" +
"0 7\r\n" +
"\r\n" +
"7";
void solve()
{
b = new char[7][8];
for(int i = 0;i < 7;i++){
b[i] = ns(8);
}
int[] co = new int[10];
for(int i = 0;i < 10;i++)co[i] = ni();
String[] PILL = {
"BY","BW","BR","BB",
"RY","RW","RR",
"WY","WW",
"YY"
};
int[][] ctp = new int[10][26];
for(int i = 0;i < 10;i++){
for(int j = 0;j < 2;j++){
ctp[i][PILL[i].charAt(j)-'A']++;
}
}
int[][] C = new int[10][10];
for(int i = 0;i < 10;i++){
for(int j = 0;j < 10;j++){
int tot = 0;
for(int k = 0;k < 26;k++){
tot += Math.min(ctp[i][k], ctp[j][k]);
}
C[i][j] = tot;
}
}
map = new int[26*26];
for(int i = 0;i < 10;i++){
int f = PILL[i].charAt(0)-'A';
int l = PILL[i].charAt(1)-'A';
map[f*26+l] = i;
map[l*26+f] = i;
}
used = new boolean[7][8];
ct = new int[10];
hist = new int[28];
ctmap = new HashMap<Integer, Datum>();
step = 0;
rec(0, 0);
int m = 10+100+10;
int[] from = new int[m];
int[] to = new int[m];
int[] c = new int[m];
int[] cap = new int[m];
int O = 0;
for(int i = 0;i < 10;i++){
from[i+O] = 20; to[i+O] = i; c[i+O] = 0; cap[i+O] = 0; // Datum
}
O += 10;
for(int i = 0;i < 10;i++){
from[i+O] = i+10; to[i+O] = 21; c[i+O] = 0; cap[i+O] = co[i];
}
O += 10;
for(int i = 0;i < 100;i++){
from[i+O] = i/10; to[i+O] = i%10+10; c[i+O] = 2-C[i/10][i%10]; cap[i+O] = 999;
}
int[][][] cost = packWD(22, from, to, c);
int[][][] capacity = packWD(22, from, to, cap);
// unweighted invgraph
// 逆グラフのcurのi番目=nextのとき、順グラフでcurはnextの何番目にあるかを返す
int n = 22;
int[][][] ig = new int[n][][];
{
int[] p = new int[n];
for(int i = 0;i < n;i++){
for(int j = 0;j < cost[i].length;j++)p[cost[i][j][0]]++;
}
for(int i = 0;i < n;i++)ig[i] = new int[p[i]][2];
for(int i = n-1;i >= 0;i--){
for(int j = 0;j < cost[i].length;j++){
int u = --p[cost[i][j][0]];
ig[cost[i][j][0]][u][0] = i;
ig[cost[i][j][0]][u][1] = j;
}
}
}
int mincost = 999;
int[] opthist = null;
int[][] optF = new int[10][10];
for(Datum d : ctmap.values()){
for(int i = 0;i < 10;i++){
capacity[20][9-i][1] = d.ct[i];
}
int mc = solveMinCostFlow(cost, capacity, ig, 20, 21, 28);
if(mc < mincost){
mincost = mc;
opthist = d.hist;
for(int i = 0;i < 10;i++){
for(int j = 0;j < 10;j++){
optF[i][j] = F[i][9-j][1];
}
}
}
}
// tr(mincost);
// tr(opthist);
//
// int S = 0;
// for(int i = 0;i < 10;i++){
// for(int j = 0;j < 10;j++){
// S += optF[i][j];
// }
// }
// if(S != 28)throw new AssertionError(S);
out.println(56-mincost);
char[][] ret = new char[13][15];
for(int i = 0;i < 13;i++){
Arrays.fill(ret[i], '.');
}
for(int h : opthist){
if(h < 64){
// |
int rr = h/8, cc = h%8;
ret[rr*2+1][cc*2] = '|';
int k = map[(b[rr][cc]-'A')*26+(b[rr+1][cc]-'A')];
for(int i = 0;i < 10;i++){
if(optF[k][i] > 0){
if(flip(b[rr][cc], b[rr+1][cc], PILL[i].charAt(0), PILL[i].charAt(1))){
ret[rr*2][cc*2] = PILL[i].charAt(1);
ret[rr*2+2][cc*2] = PILL[i].charAt(0);
}else{
ret[rr*2][cc*2] = PILL[i].charAt(0);
ret[rr*2+2][cc*2] = PILL[i].charAt(1);
}
optF[k][i]--;
break;
}
}
}else{
h -= 64;
// -
int rr = h/8, cc = h%8;
ret[rr*2][cc*2+1] = '-';
int k = map[(b[rr][cc]-'A')*26+(b[rr][cc+1]-'A')];
for(int i = 0;i < 10;i++){
if(optF[k][i] > 0){
if(flip(b[rr][cc], b[rr][cc+1], PILL[i].charAt(0), PILL[i].charAt(1))){
ret[rr*2][cc*2] = PILL[i].charAt(1);
ret[rr*2][cc*2+2] = PILL[i].charAt(0);
}else{
ret[rr*2][cc*2] = PILL[i].charAt(0);
ret[rr*2][cc*2+2] = PILL[i].charAt(1);
}
optF[k][i]--;
break;
}
}
}
}
for(int i = 0;i < 13;i++){
out.println(new String(ret[i]));
}
}
static boolean flip(char a, char b, char c, char d)
{
int d1 = (a==c?1:0) + (b==d?1:0);
int d2 = (a==d?1:0) + (b==c?1:0);
return d2 > d1;
}
public static int[][][] packWD(int n, int[] from, int[] to, int[] w)
{
int[][][] g = new int[n][][];
int[] p = new int[n];
for(int f : from)p[f]++;
for(int i = 0;i < n;i++)g[i] = new int[p[i]][2];
for(int i = 0;i < from.length;i++){
--p[from[i]];
g[from[i]][p[from[i]]][0] = to[i];
g[from[i]][p[from[i]]][1] = w[i];
}
return g;
}
int[][][] F;
public int solveMinCostFlow(int[][][] cost, int[][][] capacity, int[][][] ig, int src, int sink, int all)
{
int n = cost.length;
int[][][] flow = new int[n][][];
for(int i = 0;i < n;i++) {
flow[i] = new int[cost[i].length][2];
for(int j = 0;j < cost[i].length;j++){
flow[i][j][0] = cost[i][j][0];
}
}
int mincost = 0;
int[] pot = new int[n]; // ポテンシャル
final int[] d = new int[n];
TreeSet<Integer> q = new TreeSet<Integer>(new Comparator<Integer>(){
public int compare(Integer a, Integer b)
{
if(d[a] - d[b] != 0)return d[a] - d[b];
return a - b;
}
});
while(all > 0){
// src~sinkの最短路を探す
int[] prev = new int[n];
int[] myind = new int[n];
Arrays.fill(prev, -1);
Arrays.fill(d, Integer.MAX_VALUE / 2);
d[src] = 0;
q.clear();
q.add(src);
while(!q.isEmpty()){
int cur = q.pollFirst();
if(cur == sink)break;
for(int i = 0;i < cost[cur].length;i++) {
int next = cost[cur][i][0];
if(capacity[cur][i][1] - flow[cur][i][1] > 0){
int nd = d[cur] + cost[cur][i][1] + pot[cur] - pot[next];
if(d[next] > nd){
q.remove(next);
d[next] = nd;
prev[next] = cur;
myind[next] = i;
q.add(next);
}
}
}
for(int i = 0;i < ig[cur].length;i++) {
int next = ig[cur][i][0];
int cind = ig[cur][i][1];
if(flow[next][cind][1] > 0){
int nd = d[cur] - cost[next][cind][1] + pot[cur] - pot[next];
if(d[next] > nd){
q.remove(next);
d[next] = nd;
prev[next] = cur;
myind[next] = -cind-1;
q.add(next);
}
}
}
}
if(prev[sink] == -1)break;
int minflow = all;
int sumcost = 0;
for(int i = sink;i != src;i = prev[i]){
if(myind[i] >= 0){
minflow = Math.min(minflow, capacity[prev[i]][myind[i]][1] - flow[prev[i]][myind[i]][1]);
sumcost += cost[prev[i]][myind[i]][1];
}else{
// cur->next
// prev[i]->i
// iが持ってる
// ig[cur][j][0]=nextのときg[next][ig[cur][j][1]] = cur
int ind = -myind[i]-1;
// tr(prev[i], ind);
minflow = Math.min(minflow, flow[i][ind][1]);
sumcost -= cost[i][ind][1];
}
}
mincost += minflow * sumcost;
for(int i = sink;i != src;i = prev[i]){
if(myind[i] >= 0){
flow[prev[i]][myind[i]][1] += minflow;
}else{
int ind = -myind[i]-1;
flow[i][ind][1] -= minflow;
}
}
// tr(flow);
all -= minflow;
for(int i = 0;i < n;i++){
pot[i] += d[i];
}
}
F = flow;
return mincost;
}
static class Datum
{
public int[] ct;
public int[] hist;
}
boolean[][] used;
int[] ct;
int[] hist;
Map<Integer, Datum> ctmap;
int[] map;
char[][] b;
int step;
void rec(int r, int c)
{
if(r >= 7){
int h = Arrays.hashCode(ct);
if(!ctmap.containsKey(h)){
Datum d = new Datum();
d.ct = Arrays.copyOf(ct, 10);
d.hist = Arrays.copyOf(hist, 28);
ctmap.put(h, d);
}
return;
}
if(c >= 8){
rec(r+1, 0);
return;
}
if(used[r][c]){
rec(r, c+1);
return;
}
if(r+1 < 7 && !used[r+1][c]){
used[r][c] = true;
used[r+1][c] = true;
int kind = map[(b[r][c]-'A')*26+(b[r+1][c]-'A')];
ct[kind]++;
hist[step] = r*8+c;
step++;
rec(r, c+1);
step--;
ct[kind]--;
used[r][c] = false;
used[r+1][c] = false;
}
if(c+1 < 8 && !used[r][c+1]){
used[r][c] = true;
used[r][c+1] = true;
int kind = map[(b[r][c]-'A')*26+(b[r][c+1]-'A')];
ct[kind]++;
hist[step] = r*8+c+64;
step++;
rec(r, c+2);
step--;
ct[kind]--;
used[r][c] = false;
used[r][c+1] = false;
}
}
void run() throws Exception
{
is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
out = new PrintWriter(System.out);
long s = System.currentTimeMillis();
solve();
out.flush();
tr(System.currentTimeMillis()-s+"ms");
}
public static void main(String[] args) throws Exception
{
new E().run();
}
public int ni()
{
try {
int num = 0;
boolean minus = false;
while((num = is.read()) != -1 && !((num >= '0' && num <= '9') || num == '-'));
if(num == '-'){
num = 0;
minus = true;
}else{
num -= '0';
}
while(true){
int b = is.read();
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
}
} catch (IOException e) {
}
return -1;
}
public long nl()
{
try {
long num = 0;
boolean minus = false;
while((num = is.read()) != -1 && !((num >= '0' && num <= '9') || num == '-'));
if(num == '-'){
num = 0;
minus = true;
}else{
num -= '0';
}
while(true){
int b = is.read();
if(b >= '0' && b <= '9'){
num = num * 10 + (b - '0');
}else{
return minus ? -num : num;
}
}
} catch (IOException e) {
}
return -1;
}
public String ns()
{
try{
int b = 0;
StringBuilder sb = new StringBuilder();
while((b = is.read()) != -1 && (b == '\r' || b == '\n' || b == ' '));
if(b == -1)return "";
sb.append((char)b);
while(true){
b = is.read();
if(b == -1)return sb.toString();
if(b == '\r' || b == '\n' || b == ' ')return sb.toString();
sb.append((char)b);
}
} catch (IOException e) {
}
return "";
}
public char[] ns(int n)
{
char[] buf = new char[n];
try{
int b = 0, p = 0;
while((b = is.read()) != -1 && (b == ' ' || b == '\r' || b == '\n'));
if(b == -1)return null;
buf[p++] = (char)b;
while(p < n){
b = is.read();
if(b == -1 || b == ' ' || b == '\r' || b == '\n')break;
buf[p++] = (char)b;
}
return Arrays.copyOf(buf, p);
} catch (IOException e) {
}
return null;
}
double nd() { return Double.parseDouble(ns()); }
boolean oj = System.getProperty("ONLINE_JUDGE") != null;
void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}
|
[Æsir - CHAOS](https://soundcloud.com/kivawu/aesir-chaos)
[Æsir - V.](https://soundcloud.com/kivawu/aesir-v)
"Everything has been planned out. No more hidden concerns. The condition of Cytus is also perfect.
The time right now...... 00:01:12......
It's time."
The emotion samples are now sufficient. After almost 3 years, it's time for Ivy to awake her bonded sister, Vanessa.
The system inside A.R.C.'s Library core can be considered as an undirected graph with infinite number of processing nodes, numbered with all positive integers (1, 2, 3, …). The node with a number x (x > 1), is directly connected with a node with number (x)/(f(x)), with f(x) being the lowest prime divisor of x.
Vanessa's mind is divided into n fragments. Due to more than 500 years of coma, the fragments have been scattered: the i-th fragment is now located at the node with a number k_i! (a factorial of k_i).
To maximize the chance of successful awakening, Ivy decides to place the samples in a node P, so that the total length of paths from each fragment to P is smallest possible. If there are multiple fragments located at the same node, the path from that node to P needs to be counted multiple times.
In the world of zeros and ones, such a requirement is very simple for Ivy. Not longer than a second later, she has already figured out such a node.
But for a mere human like you, is this still possible?
For simplicity, please answer the minimal sum of paths' lengths from every fragment to the emotion samples' assembly node P.
Input
The first line contains an integer n (1 ≤ n ≤ 10^6) — number of fragments of Vanessa's mind.
The second line contains n integers: k_1, k_2, …, k_n (0 ≤ k_i ≤ 5000), denoting the nodes where fragments of Vanessa's mind are located: the i-th fragment is at the node with a number k_i!.
Output
Print a single integer, denoting the minimal sum of path from every fragment to the node with the emotion samples (a.k.a. node P).
As a reminder, if there are multiple fragments at the same node, the distance from that node to P needs to be counted multiple times as well.
Examples
Input
3
2 1 4
Output
5
Input
4
3 1 4 4
Output
6
Input
4
3 1 4 1
Output
6
Input
5
3 1 4 1 5
Output
11
Note
Considering the first 24 nodes of the system, the node network will look as follows (the nodes 1!, 2!, 3!, 4! are drawn bold):
<image>
For the first example, Ivy will place the emotion samples at the node 1. From here:
* The distance from Vanessa's first fragment to the node 1 is 1.
* The distance from Vanessa's second fragment to the node 1 is 0.
* The distance from Vanessa's third fragment to the node 1 is 4.
The total length is 5.
For the second example, the assembly node will be 6. From here:
* The distance from Vanessa's first fragment to the node 6 is 0.
* The distance from Vanessa's second fragment to the node 6 is 2.
* The distance from Vanessa's third fragment to the node 6 is 2.
* The distance from Vanessa's fourth fragment to the node 6 is again 2.
The total path length is 6.
|
#include <bits/stdc++.h>
using namespace std;
int zs[5005][5005];
int num[5005];
int mp[5005];
int main() {
mp[1] = 1;
for (int i = 2; i <= 5000; i++) {
for (int j = 2; j < i; j++) {
zs[i][j] = zs[i - 1][j];
}
int k = i;
for (int j = 2; j * j <= k; j++) {
while (!(k % j)) k /= j, zs[i][j]++, mp[i] = max(j, mp[i]);
}
if (k > 1) zs[i][k]++, mp[i] = max(k, mp[i]);
}
for (int i = 2; i <= 5000; i++) {
mp[i] = max(mp[i - 1], mp[i]);
}
int n;
long long sz = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int k;
scanf("%d", &k);
num[k]++;
}
for (int i = 1; i <= 5000; i++) {
for (int j = 1; j <= i; j++) sz += 1ll * num[i] * zs[i][j];
}
while (1) {
vector<long long> V(5005, 0);
for (int i = 1; i <= 5000; i++) {
V[mp[i]] += num[i];
}
int pos = max_element(V.begin(), V.end()) - V.begin();
long long val = V[pos];
if (n >= 2 * val || pos == 1) break;
sz -= 2 * val - n;
for (int i = 1; i <= 5000; i++) {
if (mp[i] != pos)
num[i] = 0;
else {
if (zs[i][mp[i]]) zs[i][mp[i]]--;
while (mp[i] > 1 && (!zs[i][mp[i]])) mp[i]--;
}
}
}
cout << sz << endl;
}
|
You are given an array a_1, a_2, ..., a_n. You can perform the following operation any number of times:
* Choose a pair of two neighboring equal elements a_i = a_{i + 1} (if there is at least one such pair).
* Replace them by one element with value a_i + 1.
After each such operation, the length of the array will decrease by one (and elements are renumerated accordingly). What is the minimum possible length of the array a you can get?
Input
The first line contains the single integer n (1 ≤ n ≤ 500) — the initial length of the array a.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the initial array a.
Output
Print the only integer — the minimum possible length you can get after performing the operation described above any number of times.
Examples
Input
5
4 3 2 2 3
Output
2
Input
7
3 3 4 4 4 3 3
Output
2
Input
3
1 3 5
Output
3
Input
1
1000
Output
1
Note
In the first test, this is one of the optimal sequences of operations: 4 3 2 2 3 → 4 3 3 3 → 4 4 3 → 5 3.
In the second test, this is one of the optimal sequences of operations: 3 3 4 4 4 3 3 → 4 4 4 4 3 3 → 4 4 4 4 4 → 5 4 4 4 → 5 5 4 → 6 4.
In the third and fourth tests, you can't perform the operation at all.
|
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class E {
int[] ints;
int[][] dp;
int[][] compress;
int NO = 1000000;
public static void main(String[] args) throws NumberFormatException, IOException
{
new E().run();
}
public void run() throws NumberFormatException, IOException {
//how to deal with 3 3 4 4 4
//bool[][] i,j can you compress i,j to 1
BufferedReader file = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
int N = Integer.parseInt(file.readLine());
st = new StringTokenizer(file.readLine());
ints = new int[N];
dp = new int[N][N];
compress = new int[N][N];
for(int[] in:dp)
Arrays.fill(in, -1);
for(int[] in: compress)
Arrays.fill(in, -1);
for(int i = 0;i<N;i++)
ints[i] = Integer.parseInt(st.nextToken());
System.out.println(opt(0,ints.length - 1));
/*for(int[] in: compress)
{
System.out.println(Arrays.toString(in));
}*/
//2 cases - either you can make 1 value, or there is a space where you can split
}
public int opt(int L, int R)
{
if(L == R)
return dp[L][R] = 1;
if(dp[L][R] != -1)
return dp[L][R];
if(tryCompress(L,R) != NO)
{
return dp[L][R] = 1;
}
int min = 10000;
for(int i = L;i<R;i++)
{
int left = opt(L, i);
int right = opt(i+1,R);
min = Math.min(min, left + right);
}
return dp[L][R] = min;
}
public int tryCompress(int L, int R)//returns what range is compressed to, or NO otherwise
{
if(L == R)
return compress[L][R] = ints[L];
if(compress[L][R] != -1)
return compress[L][R];
for(int i = L;i<R;i++)
{
int left = tryCompress(L, i);
int right = tryCompress(i+1, R);
if(left != NO && right != NO && left == right)
return compress[L][R] = left+1;
}
return compress[L][R] = NO;
}
public boolean testSingle(int L, int R)
{
int min = 1001;
int mindex = -1;
for(int i =L;i<=R;i++)
{
if(ints[i] < min)
{
min = ints[i];
mindex = i;
}
}
int rptr = mindex +1;
int lptr = mindex - 1;
int lookingFor = min;
while(true)
{
if(rptr != R+1 && ints[rptr] == lookingFor)
{
rptr++;
lookingFor++;
}else if(lptr != L-1 && ints[lptr] == lookingFor)
{
lptr--;
lookingFor++;
}else {
break;
}
}
return lptr == L-1 && rptr == R+1;
}
}
|
You are given three positive integers n, a and b. You have to construct a string s of length n consisting of lowercase Latin letters such that each substring of length a has exactly b distinct letters. It is guaranteed that the answer exists.
You have to answer t independent test cases.
Recall that the substring s[l ... r] is the string s_l, s_{l+1}, ..., s_{r} and its length is r - l + 1. In this problem you are only interested in substrings of length a.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2000) — the number of test cases. Then t test cases follow.
The only line of a test case contains three space-separated integers n, a and b (1 ≤ a ≤ n ≤ 2000, 1 ≤ b ≤ min(26, a)), where n is the length of the required string, a is the length of a substring and b is the required number of distinct letters in each substring of length a.
It is guaranteed that the sum of n over all test cases does not exceed 2000 (∑ n ≤ 2000).
Output
For each test case, print the answer — such a string s of length n consisting of lowercase Latin letters that each substring of length a has exactly b distinct letters. If there are multiple valid answers, print any of them. It is guaranteed that the answer exists.
Example
Input
4
7 5 3
6 1 1
6 6 1
5 2 2
Output
tleelte
qwerty
vvvvvv
abcde
Note
In the first test case of the example, consider all the substrings of length 5:
* "tleel": it contains 3 distinct (unique) letters,
* "leelt": it contains 3 distinct (unique) letters,
* "eelte": it contains 3 distinct (unique) letters.
|
import string
def construct(n, a, b):
return ((string.ascii_lowercase[:b] + "a" * (a - b)) * (n // a + 1))[:n]
t = int(input())
for i in range(t):
n, a, b = map(int, input().split())
print(construct(n, a, b))
|
Petya and Vasya are competing with each other in a new interesting game as they always do.
At the beginning of the game Petya has to come up with an array of N positive integers. Sum of all elements in his array should be equal to S. Then Petya has to select an integer K such that 0 ≤ K ≤ S.
In order to win, Vasya has to find a non-empty subarray in Petya's array such that the sum of all selected elements equals to either K or S - K. Otherwise Vasya loses.
You are given integers N and S. You should determine if Petya can win, considering Vasya plays optimally. If Petya can win, help him to do that.
Input
The first line contains two integers N and S (1 ≤ N ≤ S ≤ 10^{6}) — the required length of the array and the required sum of its elements.
Output
If Petya can win, print "YES" (without quotes) in the first line. Then print Petya's array in the second line. The array should contain N positive integers with sum equal to S. In the third line print K. If there are many correct answers, you can print any of them.
If Petya can't win, print "NO" (without quotes).
You can print each letter in any register (lowercase or uppercase).
Examples
Input
1 4
Output
YES
4
2
Input
3 4
Output
NO
Input
3 8
Output
YES
2 1 5
4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
if (2 * n <= s) {
cout << "YES\n";
for (int i = 0; i < n - 1; i++) {
cout << 2 << ' ';
s -= 2;
}
cout << s << '\n' << 1;
} else {
cout << "NO";
}
return 0;
}
|
You are given an array a of length n, which initially is a permutation of numbers from 1 to n. In one operation, you can choose an index i (1 ≤ i < n) such that a_i < a_{i + 1}, and remove either a_i or a_{i + 1} from the array (after the removal, the remaining parts are concatenated).
For example, if you have the array [1, 3, 2], you can choose i = 1 (since a_1 = 1 < a_2 = 3), then either remove a_1 which gives the new array [3, 2], or remove a_2 which gives the new array [1, 2].
Is it possible to make the length of this array equal to 1 with these operations?
Input
The first line contains a single integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n, a_i are pairwise distinct) — elements of the array.
It is guaranteed that the sum of n over all test cases doesn't exceed 3 ⋅ 10^5.
Output
For each test case, output on a single line the word "YES" if it is possible to reduce the array to a single element using the aforementioned operation, or "NO" if it is impossible to do so.
Example
Input
4
3
1 2 3
4
3 1 2 4
3
2 3 1
6
2 4 6 1 3 5
Output
YES
YES
NO
YES
Note
For the first two test cases and the fourth test case, we can operate as follow (the bolded elements are the pair chosen for that operation):
[1, 2, 3] → [1, 2] → [1]
[3, 1, 2, 4] → [3, 1, 4] → [3, 4] → [4]
[2, 4, 6, 1, 3, 5] → [4, 6, 1, 3, 5] → [4, 1, 3, 5] → [4, 1, 5] → [4, 5] → [4]
|
from sys import stdin
from math import ceil
inp = lambda : stdin.readline().strip()
t = int(inp())
for _ in range(t):
n = int(inp())
a = [int(x) for x in inp().split()]
if a[0]< a[-1]:
print('YES')
else:
print('NO')
|
Alice and Bob play a game. The game consists of several sets, and each set consists of several rounds. Each round is won either by Alice or by Bob, and the set ends when one of the players has won x rounds in a row. For example, if Bob won five rounds in a row and x = 2, then two sets ends.
You know that Alice and Bob have already played n rounds, and you know the results of some rounds. For each x from 1 to n, calculate the maximum possible number of sets that could have already finished if each set lasts until one of the players wins x rounds in a row. It is possible that the last set is still not finished — in that case, you should not count it in the answer.
Input
The first line contains one integer n (1 ≤ n ≤ 10^6) — the number of rounds.
The second line contains one string s of length n — the descriptions of rounds. If the i-th element of the string is 0, then Alice won the i-th round; if it is 1, then Bob won the i-th round, and if it is ?, then you don't know who won the i-th round.
Output
In the only line print n integers. The i-th integer should be equal to the maximum possible number of sets that could have already finished if each set lasts until one of the players wins i rounds in a row.
Examples
Input
6
11?000
Output
6 3 2 1 0 0
Input
5
01?01
Output
5 1 0 0 0
Input
12
???1??????1?
Output
12 6 4 3 2 2 1 1 1 1 1 1
Note
Let's consider the first test case:
* if x = 1 and s = 110000 or s = 111000 then there are six finished sets;
* if x = 2 and s = 110000 then there are three finished sets;
* if x = 3 and s = 111000 then there are two finished sets;
* if x = 4 and s = 110000 then there is one finished set;
* if x = 5 then there are no finished sets;
* if x = 6 then there are no finished sets.
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, las[2], p[1000100], a[1000100], f[1000100];
char s[1000100];
inline int getf(int x) { return f[x] == x ? x : f[x] = getf(f[x]); }
int main() {
n = read();
scanf("%s", s + 1);
las[0] = las[1] = n + 1;
for (int i = n; i >= 1; --i) {
if (s[i] ^ '?') las[s[i] - '0'] = i;
a[i] = max(las[0], las[1]) - i;
p[i] = i;
}
sort(p + 1, p + n + 1, [](const int i, const int j) { return a[i] < a[j]; });
int pos = 1;
for (int i = 1; i <= n + 1; ++i) {
f[i] = i;
}
for (int i = 1; i <= n; ++i) {
while (pos <= n && a[p[pos]] < i) {
f[p[pos]] = f[p[pos] + 1];
++pos;
}
int u = 1, ans = 0;
while (u <= n) {
u = getf(u);
if (u > n) break;
++ans, u += i;
}
printf("%d ", ans);
}
return 0;
}
|
A matrix of size n × m is called nice, if all rows and columns of the matrix are palindromes. A sequence of integers (a_1, a_2, ... , a_k) is a palindrome, if for any integer i (1 ≤ i ≤ k) the equality a_i = a_{k - i + 1} holds.
Sasha owns a matrix a of size n × m. In one operation he can increase or decrease any number in the matrix by one. Sasha wants to make the matrix nice. He is interested what is the minimum number of operations he needs.
Help him!
Input
The first line contains a single integer t — the number of test cases (1 ≤ t ≤ 10). The t tests follow.
The first line of each test contains two integers n and m (1 ≤ n, m ≤ 100) — the size of the matrix.
Each of the next n lines contains m integers a_{i, j} (0 ≤ a_{i, j} ≤ 10^9) — the elements of the matrix.
Output
For each test output the smallest number of operations required to make the matrix nice.
Example
Input
2
4 2
4 2
2 4
4 2
2 4
3 4
1 2 3 4
5 6 7 8
9 10 11 18
Output
8
42
Note
In the first test case we can, for example, obtain the following nice matrix in 8 operations:
2 2
4 4
4 4
2 2
In the second test case we can, for example, obtain the following nice matrix in 42 operations:
5 6 6 5
6 6 6 6
5 6 6 5
|
import sys
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(sys.stdin.readline())
def ria(): return list(map(int, sys.stdin.readline().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
import math
from collections import defaultdict
for _ in range(ri()):
n,m=ria()
l=[]
for __ in range(n):
l.append(ria())
ans=0
for i in range(n):
for j in range(m):
x=[l[i][j],l[i][m-j-1],l[n-i-1][j]]
x.sort()
y=x[1]
ans=ans+(abs(l[i][j]-y)+abs(l[i][m-j-1]-y)+abs(l[n-i-1][j]-y))
l[i][j]=l[i][m-j-1]=l[n-i-1][j]=y
print(ans)
|
You are given four integers n, c_0, c_1 and h and a binary string s of length n.
A binary string is a string consisting of characters 0 and 1.
You can change any character of the string s (the string should be still binary after the change). You should pay h coins for each change.
After some changes (possibly zero) you want to buy the string. To buy the string you should buy all its characters. To buy the character 0 you should pay c_0 coins, to buy the character 1 you should pay c_1 coins.
Find the minimum number of coins needed to buy the string.
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of the description of each test case contains four integers n, c_{0}, c_{1}, h (1 ≤ n, c_{0}, c_{1}, h ≤ 1000).
The second line of the description of each test case contains the binary string s of length n.
Output
For each test case print a single integer — the minimum number of coins needed to buy the string.
Example
Input
6
3 1 1 1
100
5 10 100 1
01010
5 10 1 1
11111
5 1 10 1
11111
12 2 1 10
101110110101
2 100 1 10
00
Output
3
52
5
10
16
22
Note
In the first test case, you can buy all characters and pay 3 coins, because both characters 0 and 1 costs 1 coin.
In the second test case, you can firstly change 2-nd and 4-th symbols of the string from 1 to 0 and pay 2 coins for that. Your string will be 00000. After that, you can buy the string and pay 5 ⋅ 10 = 50 coins for that. The total number of coins paid will be 2 + 50 = 52.
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long t;
cin >> t;
while (t--) {
long long n, c0, c1, h;
cin >> n >> c0 >> c1 >> h;
string s;
cin >> s;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long base = c0;
if (s[i] == '1') base = c1;
ans += min(base, c0 + c1 - base + h);
}
cout << ans << '\n';
}
}
|
You are given a sequence of n integers a_1, a_2, ..., a_n. Let us call an index j (2 ≤ j ≤ {{n-1}}) a hill if a_j > a_{{j+1}} and a_j > a_{{j-1}}; and let us call it a valley if a_j < a_{{j+1}} and a_j < a_{{j-1}}.
Let us define the intimidation value of a sequence as the sum of the number of hills and the number of valleys in the sequence. You can change exactly one integer in the sequence to any number that you want, or let the sequence remain unchanged. What is the minimum intimidation value that you can achieve?
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 10000) — the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 3⋅10^5).
The second line of each test case contains n space-separated integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
Output
For each test case, print a single integer — the minimum intimidation value that you can achieve.
Example
Input
4
3
1 5 3
5
2 2 2 2 2
6
1 6 2 5 2 10
5
1 6 2 5 1
Output
0
0
1
0
Note
In the first test case, changing a_2 to 2 results in no hills and no valleys.
In the second test case, the best answer is just to leave the array as it is.
In the third test case, changing a_3 to 6 results in only one valley (at the index 5).
In the fourth test case, changing a_3 to 6 results in no hills and no valleys.
|
#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<queue>
#include<stack>
#include<math.h>
#include<map>
typedef long long int ll;
using namespace std;
#define maxn 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
const int mm=3e5+100;
ll d[mm],num[mm];
int main()
{
ll n,m,i,j,t,a,b,c,p,k,kk;
scanf("%lld",&t);
while(t--)
{
scanf("%lld",&n);
for(i=1;i<=n;i++) scanf("%lld",&d[i]);
ll sum1=0;
for(i=2;i<=n-1;i++)
{
if(d[i]<d[i-1]&&d[i]<d[i+1])
{
sum1++;
}
else if(d[i]>d[i-1]&&d[i]>d[i+1])
{
sum1++;
}
}
k=0;
ll s;
for(i=2;i<=n-1;i++)
{
s=0;
if(d[i-1]>d[i]&&d[i]<d[i+1]||d[i-1]<d[i]&&d[i]>d[i+1]) s++;
if(i>=3&&(d[i]>d[i-1]&&d[i-1]<d[i-2]||d[i]<d[i-1]&&d[i-1]>d[i-2])) s++;
if(i<=n-2&&(d[i]>d[i+1]&&d[i+1]<d[i+2]||d[i]<d[i+1]&&d[i+1]>d[i+2])) s++;
{
p=d[i]; d[i]=d[i-1]; ll sum=0;
if(d[i-1]>d[i]&&d[i]<d[i+1]||d[i-1]<d[i]&&d[i]>d[i+1]) sum++;
if(i>=3&&(d[i]>d[i-1]&&d[i-1]<d[i-2]||d[i]<d[i-1]&&d[i-1]>d[i-2])) sum++;
if(i<=n-2&&(d[i]>d[i+1]&&d[i+1]<d[i+2]||d[i]<d[i+1]&&d[i+1]>d[i+2])) sum++;
k=max(k,s-sum);
d[i]=p;
}
{
p=d[i]; d[i]=d[i+1]; ll sum=0;
if(d[i-1]>d[i]&&d[i]<d[i+1]||d[i-1]<d[i]&&d[i]>d[i+1]) sum++;
if(i>=3&&(d[i]>d[i-1]&&d[i-1]<d[i-2]||d[i]<d[i-1]&&d[i-1]>d[i-2])) sum++;
if(i<=n-2&&(d[i]>d[i+1]&&d[i+1]<d[i+2]||d[i]<d[i+1]&&d[i+1]>d[i+2])) sum++;
k=max(k,s-sum);
d[i]=p;
}
}
// cout<<sum1<<' '<<k<<endl;
printf("%lld\n",sum1-k);
}
}
|
Let F_k denote the k-th term of Fibonacci sequence, defined as below:
* F_0 = F_1 = 1
* for any integer n ≥ 0, F_{n+2} = F_{n+1} + F_n
You are given a tree with n vertices. Recall that a tree is a connected undirected graph without cycles.
We call a tree a Fib-tree, if its number of vertices equals F_k for some k, and at least one of the following conditions holds:
* The tree consists of only 1 vertex;
* You can divide it into two Fib-trees by removing some edge of the tree.
Determine whether the given tree is a Fib-tree or not.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of vertices in the tree.
Then n-1 lines follow, each of which contains two integers u and v (1≤ u,v ≤ n, u ≠ v), representing an edge between vertices u and v. It's guaranteed that given edges form a tree.
Output
Print "YES" if the given tree is a Fib-tree, or "NO" otherwise.
You can print your answer in any case. For example, if the answer is "YES", then the output "Yes" or "yeS" will also be considered as correct answer.
Examples
Input
3
1 2
2 3
Output
YES
Input
5
1 2
1 3
1 4
1 5
Output
NO
Input
5
1 3
1 2
4 5
3 4
Output
YES
Note
In the first sample, we can cut the edge (1, 2), and the tree will be split into 2 trees of sizes 1 and 2 correspondently. Any tree of size 2 is a Fib-tree, as it can be split into 2 trees of size 1.
In the second sample, no matter what edge we cut, the tree will be split into 2 trees of sizes 1 and 4. As 4 isn't F_k for any k, it's not Fib-tree.
In the third sample, here is one possible order of cutting the edges so that all the trees in the process are Fib-trees: (1, 3), (1, 2), (4, 5), (3, 4).
|
import java.util.*;
import java.io.*;
public class E1491 {
static ArrayList<Edge>[] adjList;
static int[] subTree;
static int[] fib;
static class Edge {
int u, v;
boolean valid;
int myNode, mySize;
public Edge(int u, int v) {
this.u = u;
this.v = v;
valid = true;
}
int other(int x) {
return u ^ v ^ x;
}
void close() {
valid = false;
}
}
public static Edge dfs(int u, int p, int size, Edge cur) {
subTree[u] = 1;
Edge ans = null;
for (Edge e : adjList[u]) {
if (!e.valid)
continue;
int x = e.other(u);
if (x != p) {
Edge c = dfs(x, u, size, e);
if (c != null)
ans = c;
subTree[u] += subTree[x];
}
}
if (subTree[u] == fib[size - 1]) {
ans = cur;
ans.myNode = u;
ans.mySize = size - 1;
} else if (subTree[u] == fib[size - 2]) {
ans = cur;
ans.myNode = u;
ans.mySize = size - 2;
}
return ans;
}
public static boolean solve(int u, int size) {
if (fib[size] <= 3)
return true;
Edge x = dfs(u, -1, size, null);
if (x == null)
return false;
x.close();
return solve(x.myNode, x.mySize) && solve(x.other(x.myNode), (x.mySize == size - 1 ? size - 2 : (size - 1)));
}
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int n = sc.nextInt();
adjList = new ArrayList[n];
for (int i = 0; i < adjList.length; i++) {
adjList[i] = new ArrayList<Edge>();
}
for (int i = 0; i < n - 1; i++) {
int u = sc.nextInt() - 1;
int v = sc.nextInt() - 1;
Edge e = new Edge(u, v);
adjList[u].add(e);
adjList[v].add(e);
}
subTree = new int[n];
fib = new int[30];
fib[0] = 1;
fib[1] = 1;
for (int i = 2; i < fib.length; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
}
// pw.println(Arrays.toString(fib));
int size = -1;
for (int i = 0; i < fib.length; i++) {
if (fib[i] == n) {
size = i;
}
}
if (size == -1) {
pw.println("NO");
} else {
pw.println(solve(0, size) ? "YES" : "NO");
}
pw.close();
}
static class Scanner {
BufferedReader br;
StringTokenizer st;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public Scanner(FileReader f) {
br = new BufferedReader(f);
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public int[] nextIntArr(int n) throws IOException {
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(next());
}
return arr;
}
}
}
|
Baby Badawy's first words were "AND 0 SUM BIG", so he decided to solve the following problem. Given two integers n and k, count the number of arrays of length n such that:
* all its elements are integers between 0 and 2^k-1 (inclusive);
* the [bitwise AND](https://en.wikipedia.org/wiki/Bitwise_operation#AND) of all its elements is 0;
* the sum of its elements is as large as possible.
Since the answer can be very large, print its remainder when divided by 10^9+7.
Input
The first line contains an integer t (1 ≤ t ≤ 10) — the number of test cases you need to solve.
Each test case consists of a line containing two integers n and k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 20).
Output
For each test case, print the number of arrays satisfying the conditions. Since the answer can be very large, print its remainder when divided by 10^9+7.
Example
Input
2
2 2
100000 20
Output
4
226732710
Note
In the first example, the 4 arrays are:
* [3,0],
* [0,3],
* [1,2],
* [2,1].
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
const ll mod = 1e9 + 7;
#define inf 1e18 + 3
#define pb push_back
#define mp make_pair
void solve() {
int n, k;
cin >> n >> k;
ll ans = 1;
while (k > 0) {
ans = (ans * n) % mod;
k--;
}
cout << ans << '\n';
}
signed main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
cin >> t;
while (t--)solve();
return 0;
}
|
You are given an array a_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t cases follow.
The first line of each test case contains one integer n (2 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n space separated integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ n) — the array a. It is guaranteed that all elements are distinct.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output the number of pairs of indices (i, j) such that i < j and a_i ⋅ a_j = i + j.
Example
Input
3
2
3 1
3
6 1 5
5
3 1 5 9 2
Output
1
1
3
Note
For the first test case, the only pair that satisfies the constraints is (1, 2), as a_1 ⋅ a_2 = 1 + 2 = 3
For the second test case, the only pair that satisfies the constraints is (2, 3).
For the third test case, the pairs that satisfy the constraints are (1, 2), (1, 5), and (2, 3).
|
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define fi first
#define se second
#define maxn 200005
#define inf 1e9
#define maxi LONG_LONG_MAX
#define mini LONG_LONG_MIN
#define sz(x) (x).size()
#define ed(x) (x).end()
#define contains(v,i) (v.find(i)!=v.end())
#define grt_sort(x) sort(x.begin(),x.end(),greater<>())
#define pll pair<ll,ll>
#define flash ios_base::sync_with_stdio(false);cin.tie(NULL);
using namespace std;
int main()
{
flash
ll t;
cin>>t;
while(t--){
ll n;
cin>>n;
vector<pll> v;
for(ll i=0;i<n;i++){
ll x;
cin>>x;
v.pb({x,i+1});
}
sort(v.begin(),v.end());
ll cnt=0;
for(ll i=n-1;i>=0;i--){
for(ll j=0;j<i;j++){
if((v[i].first * v[j].first)>(2*n-1))
break;
if((v[i].first * v[j].first)==(v[i].second+v[j].second))
cnt++;
}
}
cout<<cnt<<"\n";
}
}
|
Petya and Vasya are brothers. Today is a special day for them as their parents left them home alone and commissioned them to do n chores. Each chore is characterized by a single parameter — its complexity. The complexity of the i-th chore equals hi.
As Petya is older, he wants to take the chores with complexity larger than some value x (hi > x) to leave to Vasya the chores with complexity less than or equal to x (hi ≤ x). The brothers have already decided that Petya will do exactly a chores and Vasya will do exactly b chores (a + b = n).
In how many ways can they choose an integer x so that Petya got exactly a chores and Vasya got exactly b chores?
Input
The first input line contains three integers n, a and b (2 ≤ n ≤ 2000; a, b ≥ 1; a + b = n) — the total number of chores, the number of Petya's chores and the number of Vasya's chores.
The next line contains a sequence of integers h1, h2, ..., hn (1 ≤ hi ≤ 109), hi is the complexity of the i-th chore. The numbers in the given sequence are not necessarily different.
All numbers on the lines are separated by single spaces.
Output
Print the required number of ways to choose an integer value of x. If there are no such ways, print 0.
Examples
Input
5 2 3
6 2 3 100 1
Output
3
Input
7 3 4
1 1 9 1 1 1 1
Output
0
Note
In the first sample the possible values of x are 3, 4 or 5.
In the second sample it is impossible to find such x, that Petya got 3 chores and Vasya got 4.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
long a[2000];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
cout << a[y] - a[y - 1];
return 0;
}
|
PMP is getting a warrior. He is practicing a lot, but the results are not acceptable yet. This time instead of programming contests, he decided to compete in a car racing to increase the spirit of victory. He decides to choose a competition that also exhibits algorithmic features.
AlgoRace is a special league of car racing where different teams compete in a country of n cities. Cities are numbered 1 through n. Every two distinct cities in the country are connected with one bidirectional road. Each competing team should introduce one driver and a set of cars.
The competition is held in r rounds. In i-th round, drivers will start at city si and finish at city ti. Drivers are allowed to change their cars at most ki times. Changing cars can take place in any city in no time. One car can be used multiple times in one round, but total number of changes should not exceed ki. Drivers can freely choose their path to destination.
PMP has prepared m type of purpose-built cars. Beside for PMP’s driving skills, depending on properties of the car and the road, a car traverses each road in each direction in different times.
PMP Warriors wants to devise best strategies of choosing car and roads in each round to maximize the chance of winning the cup. For each round they want to find the minimum time required to finish it.
Input
The first line contains three space-separated integers n, m, r (2 ≤ n ≤ 60, 1 ≤ m ≤ 60, 1 ≤ r ≤ 105) — the number of cities, the number of different types of cars and the number of rounds in the competition, correspondingly.
Next m sets of n × n matrices of integers between 0 to 106 (inclusive) will follow — describing the time one car requires to traverse different roads. The k-th integer in j-th line of the i-th set is the time that i-th car requires to traverse the road from j-th city to k-th city. These matrices are not necessarily symmetric, but their diagonal is always zero.
Next r lines contain description of the rounds. The i-th of these lines contains space-separated integers si, ti, ki (1 ≤ si, ti ≤ n, si ≠ ti, 0 ≤ ki ≤ 1000) — the number of starting city, finishing city and the number of possible car changes in i-th round, correspondingly.
Output
For each round you should print the minimum required time to complete the round in a single line.
Examples
Input
4 2 3
0 1 5 6
2 0 3 6
1 3 0 1
6 6 7 0
0 3 5 6
2 0 1 6
1 3 0 2
6 6 7 0
1 4 2
1 4 1
1 4 3
Output
3
4
3
Input
4 2 3
0 7 3 3
8 0 10 5
1 1 0 4
8 9 2 0
0 3 3 9
7 0 4 9
3 8 0 4
4 8 9 0
2 3 3
2 1 3
1 2 2
Output
4
5
3
Note
In the first sample, in all rounds PMP goes from city #1 to city #2, then city #3 and finally city #4. But the sequences of types of the cars he uses are (1, 2, 1) in the first round and (1, 2, 2) in the second round. In the third round, although he can change his car three times, he uses the same strategy as the first round which only needs two car changes.
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int g[70][70][70];
int dp[70][70][70];
void solve() {
int n, m, r;
scanf("%d%d%d", &n, &m, &r);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
scanf("%d", &g[i][j][k]);
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
for (int u = 1; u <= n; u++) {
g[i][k][u] = min(g[i][k][u], g[i][k][j] + g[i][j][u]);
}
}
}
}
for (int i = 0; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
dp[i][j][k] = 1000000007;
}
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
for (int u = 1; u <= n; u++) {
dp[0][k][u] = min(dp[0][k][u], g[i][k][u]);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
for (int u = 1; u <= n; u++) {
dp[i][k][u] = min(dp[i][k][u], dp[i - 1][k][j] + dp[0][j][u]);
}
}
}
}
while (r--) {
int s, e, k;
int ans = 1000000007;
scanf("%d%d%d", &s, &e, &k);
k = min(n, k);
for (int i = 0; i <= k; i++) ans = min(ans, dp[i][s][e]);
printf("%d\n", ans);
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
|
Vasya the carpenter has an estate that is separated from the wood by a fence. The fence consists of n planks put in a line. The fence is not closed in a circle. The planks are numbered from left to right from 1 to n, the i-th plank is of height ai. All planks have the same width, the lower edge of each plank is located at the ground level.
Recently a local newspaper "Malevich and Life" wrote that the most fashionable way to decorate a fence in the summer is to draw a fuchsia-colored rectangle on it, the lower side of the rectangle must be located at the lower edge of the fence.
Vasya is delighted with this idea! He immediately bought some fuchsia-colored paint and began to decide what kind of the rectangle he should paint. Vasya is sure that the rectangle should cover k consecutive planks. In other words, he will paint planks number x, x + 1, ..., x + k - 1 for some x (1 ≤ x ≤ n - k + 1). He wants to paint the rectangle of maximal area, so the rectangle height equals min ai for x ≤ i ≤ x + k - 1, x is the number of the first colored plank.
Vasya has already made up his mind that the rectangle width can be equal to one of numbers of the sequence k1, k2, ..., km. For each ki he wants to know the expected height of the painted rectangle, provided that he selects x for such fence uniformly among all n - ki + 1 possible values. Help him to find the expected heights.
Input
The first line contains a single integer n (1 ≤ n ≤ 106) — the number of planks in the fence. The second line contains a sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109) where ai is the height of the i-th plank of the fence.
The third line contains an integer m (1 ≤ m ≤ 106) and the next line contains m space-separated integers k1, k2, ..., km (1 ≤ ki ≤ n) where ki is the width of the desired fuchsia-colored rectangle in planks.
Output
Print m whitespace-separated real numbers, the i-th number equals the expected value of the rectangle height, if its width in planks equals ki. The value will be considered correct if its absolute or relative error doesn't exceed 10 - 9.
Examples
Input
3
3 2 1
3
1 2 3
Output
2.000000000000000
1.500000000000000
1.000000000000000
Input
2
1 1
3
1 2 1
Output
1.000000000000000
1.000000000000000
1.000000000000000
Note
Let's consider the first sample test.
* There are three possible positions of the fence for k1 = 1. For the first position (x = 1) the height is 3, for the second one (x = 2) the height is 2, for the third one (x = 3) the height is 1. As the fence position is chosen uniformly, the expected height of the fence equals <image>;
* There are two possible positions of the fence for k2 = 2. For the first position (x = 1) the height is 2, for the second one (x = 2) the height is 1. The expected height of the fence equals <image>;
* There is the only possible position of the fence for k3 = 3. The expected height of the fence equals 1.
|
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
const long long int INFLL = 0x3f3f3f3f3f3f3f3fll;
long long int getint() {
long long int ret = 0;
bool f = 0;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') f ^= 1;
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return f ? -ret : ret;
}
using namespace std;
const int MAXN = 1000000;
int a[MAXN + 10], L[MAXN + 10], R[MAXN + 10];
int stk[MAXN + 10];
long long int p[MAXN + 10], ans[MAXN + 10];
int main() {
int n = getint();
for (int i = 1; i <= n; ++i) a[i] = getint();
int top = 0;
for (int i = 1; i <= n; ++i) {
while (top && a[stk[top]] >= a[i]) {
R[stk[top]] = i - stk[top];
--top;
}
stk[++top] = i;
L[i] = i - stk[top - 1];
}
for (int i = 1; i <= top; ++i) R[stk[i]] = n + 1 - stk[i];
for (int i = 1; i <= n; ++i) {
if (L[i] > R[i]) swap(L[i], R[i]);
p[1] += a[i];
p[L[i] + 1] -= a[i];
p[R[i] + 1] -= a[i];
p[L[i] + R[i] + 1] += a[i];
}
long long int ret = 0, t = 0;
for (int i = 1; i <= n; ++i) {
t += p[i];
ret += t;
ans[i] = ret;
}
int q = getint();
while (q--) {
int k = getint();
printf("%.15f\n", 1.0 * ans[k] / (n - k + 1));
}
}
|
You're playing a game called Osu! Here's a simplified version of it. There are n clicks in a game. For each click there are two outcomes: correct or bad. Let us denote correct as "O", bad as "X", then the whole play can be encoded as a sequence of n characters "O" and "X".
Using the play sequence you can calculate the score for the play as follows: for every maximal consecutive "O"s block, add the square of its length (the number of characters "O") to the score. For example, if your play can be encoded as "OOXOOOXXOO", then there's three maximal consecutive "O"s block "OO", "OOO", "OO", so your score will be 22 + 32 + 22 = 17. If there are no correct clicks in a play then the score for the play equals to 0.
You know that the probability to click the i-th (1 ≤ i ≤ n) click correctly is pi. In other words, the i-th character in the play sequence has pi probability to be "O", 1 - pi to be "X". You task is to calculate the expected score for your play.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of clicks. The second line contains n space-separated real numbers p1, p2, ..., pn (0 ≤ pi ≤ 1).
There will be at most six digits after the decimal point in the given pi.
Output
Print a single real number — the expected score for your play. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
3
0.5 0.5 0.5
Output
2.750000000000000
Input
4
0.7 0.2 0.1 0.9
Output
2.489200000000000
Input
5
1 1 1 1 1
Output
25.000000000000000
Note
For the first example. There are 8 possible outcomes. Each has a probability of 0.125.
* "OOO" → 32 = 9;
* "OOX" → 22 = 4;
* "OXO" → 12 + 12 = 2;
* "OXX" → 12 = 1;
* "XOO" → 22 = 4;
* "XOX" → 12 = 1;
* "XXO" → 12 = 1;
* "XXX" → 0.
So the expected score is <image>
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-5;
const int inf = (1 << 31) - 1;
const int hinf = 1000000000;
const int mod = 1000000007;
int main() {
double e = 1;
int n;
cin >> n;
double p;
double ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%lf", &p);
ans += e * p;
e = 1 + (1 + e) * p;
}
printf("%.15lf\n", ans);
}
|
Maxim has opened his own restaurant! The restaurant has got a huge table, the table's length is p meters.
Maxim has got a dinner party tonight, n guests will come to him. Let's index the guests of Maxim's restaurant from 1 to n. Maxim knows the sizes of all guests that are going to come to him. The i-th guest's size (ai) represents the number of meters the guest is going to take up if he sits at the restaurant table.
Long before the dinner, the guests line up in a queue in front of the restaurant in some order. Then Maxim lets the guests in, one by one. Maxim stops letting the guests in when there is no place at the restaurant table for another guest in the queue. There is no place at the restaurant table for another guest in the queue, if the sum of sizes of all guests in the restaurant plus the size of this guest from the queue is larger than p. In this case, not to offend the guest who has no place at the table, Maxim doesn't let any other guest in the restaurant, even if one of the following guests in the queue would have fit in at the table.
Maxim is now wondering, what is the average number of visitors who have come to the restaurant for all possible n! orders of guests in the queue. Help Maxim, calculate this number.
Input
The first line contains integer n (1 ≤ n ≤ 50) — the number of guests in the restaurant. The next line contains integers a1, a2, ..., an (1 ≤ ai ≤ 50) — the guests' sizes in meters. The third line contains integer p (1 ≤ p ≤ 50) — the table's length in meters.
The numbers in the lines are separated by single spaces.
Output
In a single line print a real number — the answer to the problem. The answer will be considered correct, if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3
1 2 3
3
Output
1.3333333333
Note
In the first sample the people will come in the following orders:
* (1, 2, 3) — there will be two people in the restaurant;
* (1, 3, 2) — there will be one person in the restaurant;
* (2, 1, 3) — there will be two people in the restaurant;
* (2, 3, 1) — there will be one person in the restaurant;
* (3, 1, 2) — there will be one person in the restaurant;
* (3, 2, 1) — there will be one person in the restaurant.
In total we get (2 + 1 + 2 + 1 + 1 + 1) / 6 = 8 / 6 = 1.(3).
|
#include <bits/stdc++.h>
using namespace std;
int N, P;
int A[50];
long long dp[52][52][52][52];
double C[52][52];
double fac[52], res;
int main() {
scanf("%d", &N);
for (int(i) = 0; (i) < (N); (i)++) scanf("%d", &A[i]);
scanf("%d", &P);
C[0][0] = 1;
for (int(i) = (1); (i) < (52); (i)++)
for (int(j) = 0; (j) < (i + 1); (j)++) {
if (j) C[i][j] = C[i - 1][j - 1];
C[i][j] += C[i - 1][j];
}
fac[0] = 1;
for (int(i) = (1); (i) < (52); (i)++) fac[i] = fac[i - 1] * i;
for (int(can) = (0); (can) < (P + 1); (can)++) {
memset((dp), (0), sizeof(dp));
dp[0][can][0][0] = 1;
for (int(i) = 0; (i) < (N); (i)++)
for (int(j) = 0; (j) < (can + 1); (j)++)
for (int(k) = 0; (k) < (N + 1); (k)++)
for (int(l) = 0; (l) < (N + 1); (l)++)
if (dp[i][j][k][l]) {
if (A[i] >= P - can)
dp[i + 1][j][k + 1][l] += dp[i][j][k][l];
else
dp[i + 1][j][k][l] += dp[i][j][k][l];
if (A[i] <= j) dp[i + 1][j - A[i]][k][l + 1] += dp[i][j][k][l];
}
for (int(k) = 0; (k) < (N + 1); (k)++)
for (int(l) = 0; (l) < (N + 1); (l)++) {
if (dp[N][0][k][l] && l - 1 >= 0)
res += fac[N - l] * l * fac[l - 1] * dp[N][0][k][l];
}
}
printf("%.12f\n", res / fac[N]);
}
|
Petya and Vasya are playing a game. Petya's got n non-transparent glasses, standing in a row. The glasses' positions are indexed with integers from 1 to n from left to right. Note that the positions are indexed but the glasses are not.
First Petya puts a marble under the glass in position s. Then he performs some (possibly zero) shuffling operations. One shuffling operation means moving the glass from the first position to position p1, the glass from the second position to position p2 and so on. That is, a glass goes from position i to position pi. Consider all glasses are moving simultaneously during one shuffling operation. When the glasses are shuffled, the marble doesn't travel from one glass to another: it moves together with the glass it was initially been put in.
After all shuffling operations Petya shows Vasya that the ball has moved to position t. Vasya's task is to say what minimum number of shuffling operations Petya has performed or determine that Petya has made a mistake and the marble could not have got from position s to position t.
Input
The first line contains three integers: n, s, t (1 ≤ n ≤ 105; 1 ≤ s, t ≤ n) — the number of glasses, the ball's initial and final position. The second line contains n space-separated integers: p1, p2, ..., pn (1 ≤ pi ≤ n) — the shuffling operation parameters. It is guaranteed that all pi's are distinct.
Note that s can equal t.
Output
If the marble can move from position s to position t, then print on a single line a non-negative integer — the minimum number of shuffling operations, needed to get the marble to position t. If it is impossible, print number -1.
Examples
Input
4 2 1
2 3 4 1
Output
3
Input
4 3 3
4 1 3 2
Output
0
Input
4 3 4
1 2 3 4
Output
-1
Input
3 1 3
2 1 3
Output
-1
|
import java.util.*;
public class Main {
public static void main(String[] strings) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int s = scan.nextInt() - 1;
int t = scan.nextInt() - 1;
int[] p = new int[n];
for (int i = 0; i < p.length; ++i) {
p[i] = scan.nextInt() - 1;
}
boolean[] used = new boolean[n];
int res = 0;
for (int i = s; !used[i]; i = p[i], ++res) {
used[i] = true;
if (i == t) {
System.out.println(res);
return;
}
}
System.out.println(-1);
scan.close();
}
}
|
The king Copa often has been reported about the Codeforces site, which is rapidly getting more and more popular among the brightest minds of the humanity, who are using it for training and competing. Recently Copa understood that to conquer the world he needs to organize the world Codeforces tournament. He hopes that after it the brightest minds will become his subordinates, and the toughest part of conquering the world will be completed.
The final round of the Codeforces World Finals 20YY is scheduled for DD.MM.YY, where DD is the day of the round, MM is the month and YY are the last two digits of the year. Bob is lucky to be the first finalist form Berland. But there is one problem: according to the rules of the competition, all participants must be at least 18 years old at the moment of the finals. Bob was born on BD.BM.BY. This date is recorded in his passport, the copy of which he has already mailed to the organizers. But Bob learned that in different countries the way, in which the dates are written, differs. For example, in the US the month is written first, then the day and finally the year. Bob wonders if it is possible to rearrange the numbers in his date of birth so that he will be at least 18 years old on the day DD.MM.YY. He can always tell that in his motherland dates are written differently. Help him.
According to another strange rule, eligible participant must be born in the same century as the date of the finals. If the day of the finals is participant's 18-th birthday, he is allowed to participate.
As we are considering only the years from 2001 to 2099 for the year of the finals, use the following rule: the year is leap if it's number is divisible by four.
Input
The first line contains the date DD.MM.YY, the second line contains the date BD.BM.BY. It is guaranteed that both dates are correct, and YY and BY are always in [01;99].
It could be that by passport Bob was born after the finals. In this case, he can still change the order of numbers in date.
Output
If it is possible to rearrange the numbers in the date of birth so that Bob will be at least 18 years old on the DD.MM.YY, output YES. In the other case, output NO.
Each number contains exactly two digits and stands for day, month or year in a date. Note that it is permitted to rearrange only numbers, not digits.
Examples
Input
01.01.98
01.01.80
Output
YES
Input
20.10.20
10.02.30
Output
NO
Input
28.02.74
28.02.64
Output
NO
|
#include <bits/stdc++.h>
using namespace std;
int main() {
struct date {
int d, m, y;
date(){};
date(int D, int M, int Y) {
d = D;
m = M;
y = Y;
if (m > 12 || d > 31 ||
(d == 31 && (m == 2 || m == 4 || m == 6 || m == 9 || m == 11)) ||
(d == 30 && m == 2) || (d == 29 && m == 2 && y % 4)) {
d = 99;
m = 99;
y = 99;
}
}
bool operator-(const date &b) {
date c = *this;
c.y -= b.y;
c.m -= b.m;
c.d -= b.d;
if (c.d < 0) c.m--;
if (c.m < 0) c.y--;
if (c.y >= 18) return true;
return false;
}
};
int a, b, c;
scanf("%d.%d.%d", &a, &b, &c);
date f(a, b, c);
scanf("%d.%d.%d", &a, &b, &c);
if (f - date(a, b, c) || f - date(a, c, b) || f - date(b, a, c) ||
f - date(b, c, a) || f - date(c, a, b) || f - date(c, b, a))
cout << "YES";
else
cout << "NO";
return 0;
}
|
Let's assume that p and q are strings of positive length, called the container and the key correspondingly, string q only consists of characters 0 and 1. Let's take a look at a simple algorithm that extracts message s from the given container p:
i = 0;
j = 0;
s = <>;
while i is less than the length of the string p
{
if q[j] == 1, then add to the right of string s character p[i];
increase variables i, j by one;
if the value of the variable j equals the length of the string q, then j = 0;
}
In the given pseudocode i, j are integer variables, s is a string, '=' is an assignment operator, '==' is a comparison operation, '[]' is the operation of obtaining the string character with the preset index, '<>' is an empty string. We suppose that in all strings the characters are numbered starting from zero.
We understand that implementing such algorithm is quite easy, so your task is going to be slightly different. You need to construct the lexicographically minimum key of length k, such that when it is used, the algorithm given above extracts message s from container p (otherwise find out that such key doesn't exist).
Input
The first two lines of the input are non-empty strings p and s (1 ≤ |p| ≤ 106, 1 ≤ |s| ≤ 200), describing the container and the message, correspondingly. The strings can contain any characters with the ASCII codes from 32 to 126, inclusive.
The third line contains a single integer k (1 ≤ k ≤ 2000) — the key's length.
Output
Print the required key (string of length k, consisting only of characters 0 and 1). If the key doesn't exist, print the single character 0.
Examples
Input
abacaba
aba
6
Output
100001
Input
abacaba
aba
3
Output
0
Note
String x = x1x2... xp is lexicographically smaller than string y = y1y2... yq, if either p < q and x1 = y1, x2 = y2, ... , xp = yp, or there exists such integer r (0 ≤ r < min(p, q)) that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. Symbols are compared according to their ASCII codes.
|
#include <bits/stdc++.h>
using namespace std;
const int MAXS = 200;
const int MAXP = 1e6;
const int MAXK = 2000;
bool canTake[MAXS + 5][MAXK + 5][MAXS + 5];
char s[MAXS + 5], p[MAXP + 5];
int S, P, K;
bool best[MAXK + 5][MAXS + 5];
bool vis[MAXK + 5][MAXS + 5];
bool decision[MAXK + 5][MAXS + 5];
int ones;
bool solve(int i_p, int i_s) {
if (i_p == K && i_s == ones) return true;
if (i_s > ones) return false;
if (i_p == K) return false;
bool& ret = best[i_p][i_s];
if (vis[i_p][i_s]) return ret;
vis[i_p][i_s] = true;
decision[i_p][i_s] = 0;
ret = solve(i_p + 1, i_s);
if (!ret && canTake[ones][i_p][i_s] && solve(i_p + 1, i_s + 1)) {
ret = 1;
decision[i_p][i_s] = 1;
}
return ret;
}
void pre() {
for (int ones = 1; ones <= S; ones++) {
for (int i1 = 0; i1 < K; i1++) {
for (int i2 = 0; i2 < ones; i2++) {
int j1, j2;
for (j1 = i1, j2 = i2; j1 < P && j2 < S && p[j1] == s[j2];
j1 += K, j2 += ones)
;
canTake[ones][i1][i2] = j1 >= P && j2 >= S;
}
}
}
}
string construct() {
string ret = "";
int i1, i2 = 0;
for (i1 = 0; i1 < K; i1++) {
ret += '0' + decision[i1][i2];
i2 += decision[i1][i2];
}
return ret;
}
int main() {
int c, c2;
gets(p);
gets(s);
scanf("%d", &K);
P = strlen(p);
S = strlen(s);
pre();
string ret;
for (ones = 1; ones <= S; ones++) {
memset(vis, 0, sizeof(vis));
if (solve(0, 0)) {
string cur = construct();
if (ret.size() == 0 || ret > cur) ret = cur;
}
}
if (ret.size() == 0) ret = "0";
printf("%s\n", ret.c_str());
return 0;
}
|
Vasya's got a birthday coming up and his mom decided to give him an array of positive integers a of length n.
Vasya thinks that an array's beauty is the greatest common divisor of all its elements. His mom, of course, wants to give him as beautiful an array as possible (with largest possible beauty). Unfortunately, the shop has only one array a left. On the plus side, the seller said that he could decrease some numbers in the array (no more than by k for each number).
The seller can obtain array b from array a if the following conditions hold: bi > 0; 0 ≤ ai - bi ≤ k for all 1 ≤ i ≤ n.
Help mom find the maximum possible beauty of the array she will give to Vasya (that seller can obtain).
Input
The first line contains two integers n and k (1 ≤ n ≤ 3·105; 1 ≤ k ≤ 106). The second line contains n integers ai (1 ≤ ai ≤ 106) — array a.
Output
In the single line print a single number — the maximum possible beauty of the resulting array.
Examples
Input
6 1
3 6 10 12 13 16
Output
3
Input
5 3
8 21 52 15 77
Output
7
Note
In the first sample we can obtain the array:
3 6 9 12 12 15
In the second sample we can obtain the next array:
7 21 49 14 77
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300050;
const int maxv = 1000050 * 2;
int n, k, a[maxn], mp[maxv], p[maxv];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
n = read();
k = read();
int a, t = 10000000;
for (int i = 1; i <= n; ++i) mp[a = read()]++, t = min(t, a);
for (int i = 1; i <= maxv; ++i) mp[i] += mp[i - 1];
for (int i = 1; i <= maxv; ++i) p[i] = mp[min(maxv, i + k)] - mp[i - 1];
int ans = min(t, k);
for (int i = k + 1; i <= t; ++i) {
int j = i;
int tmp = 0;
while (j <= maxv) {
tmp += p[j];
j = j + i;
}
if (tmp == n) ans = i;
}
printf("%d\n", ans);
return 0;
}
|
You are a programmer and you have a New Year Tree (not the traditional fur tree, though) — a tree of four vertices: one vertex of degree three (has number 1), connected with three leaves (their numbers are from 2 to 4).
On the New Year, programmers usually have fun. You decided to have fun as well by adding vertices to the tree. One adding operation looks as follows:
* First we choose some leaf of the tree with number v.
* Let's mark the number of vertices on the tree at this moment by variable n, then two vertexes are added to the tree, their numbers are n + 1 and n + 2, also you get new edges, one between vertices v and n + 1 and one between vertices v and n + 2.
Your task is not just to model the process of adding vertices to the tree, but after each adding operation print the diameter of the current tree. Come on, let's solve the New Year problem!
Input
The first line contains integer q (1 ≤ q ≤ 5·105) — the number of operations. Each of the next q lines contains integer vi (1 ≤ vi ≤ n) — the operation of adding leaves to vertex vi. Variable n represents the number of vertices in the current tree.
It is guaranteed that all given operations are correct.
Output
Print q integers — the diameter of the current tree after each operation.
Examples
Input
5
2
3
4
8
5
Output
3
4
4
5
6
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dis_u, dis_v, dis;
int dep[1500005], dp[1500005][25];
void init() {
n = 4;
dep[1] = 1;
dep[2] = dep[3] = dep[4] = 2;
dp[2][0] = dp[3][0] = dp[4][0] = 1;
dis = 2;
dis_u = 2;
dis_v = 3;
}
void update(int u) {
for (int i = 1; i <= 20; i++) dp[u][i] = dp[dp[u][i - 1]][i - 1];
}
int lca(int u, int v) {
int s = 0;
if (u == v) return 0;
if (dep[u] > dep[v]) swap(u, v);
for (int i = 20; i >= 0; i--)
if (dep[u] <= dep[dp[v][i]]) {
s = s + (1 << i);
v = dp[v][i];
}
if (u == v) return s;
for (int i = 20; i >= 0; i--)
if (dp[u][i] != dp[v][i]) {
s = s + (1 << (i + 1));
u = dp[u][i];
v = dp[v][i];
}
return s + 2;
}
int main() {
ios::sync_with_stdio(false);
init();
cin >> m;
for (int i = 1, u; i <= m; i++) {
cin >> u;
dp[n + 1][0] = u;
dp[n + 2][0] = u;
dep[n + 1] = dep[u] + 1;
dep[n + 2] = dep[u] + 1;
update(n + 1);
update(n + 2);
int t1 = lca(n + 1, dis_u);
int t2 = lca(n + 1, dis_v);
if (max(t1, t2) > dis) {
if (t1 > t2) {
dis_v = n + 1;
dis = t1;
} else {
dis_u = n + 1;
dis = t2;
}
}
cout << dis << '\n';
n += 2;
}
return 0;
}
|
A group of tourists is going to kayak and catamaran tour. A rented lorry has arrived to the boat depot to take kayaks and catamarans to the point of departure. It's known that all kayaks are of the same size (and each of them occupies the space of 1 cubic metre), and all catamarans are of the same size, but two times bigger than kayaks (and occupy the space of 2 cubic metres).
Each waterborne vehicle has a particular carrying capacity, and it should be noted that waterborne vehicles that look the same can have different carrying capacities. Knowing the truck body volume and the list of waterborne vehicles in the boat depot (for each one its type and carrying capacity are known), find out such set of vehicles that can be taken in the lorry, and that has the maximum total carrying capacity. The truck body volume of the lorry can be used effectively, that is to say you can always put into the lorry a waterborne vehicle that occupies the space not exceeding the free space left in the truck body.
Input
The first line contains a pair of integer numbers n and v (1 ≤ n ≤ 105; 1 ≤ v ≤ 109), where n is the number of waterborne vehicles in the boat depot, and v is the truck body volume of the lorry in cubic metres. The following n lines contain the information about the waterborne vehicles, that is a pair of numbers ti, pi (1 ≤ ti ≤ 2; 1 ≤ pi ≤ 104), where ti is the vehicle type (1 – a kayak, 2 – a catamaran), and pi is its carrying capacity. The waterborne vehicles are enumerated in order of their appearance in the input file.
Output
In the first line print the maximum possible carrying capacity of the set. In the second line print a string consisting of the numbers of the vehicles that make the optimal set. If the answer is not unique, print any of them.
Examples
Input
3 2
1 2
2 7
1 3
Output
7
2
|
n, v = map(int, input().split())
a = []
b = []
for i in range(n):
typ, carry = map(int, input().split())
if typ == 1:
a.append([carry, i + 1])
else:
b.append([carry, i + 1])
a.sort(reverse=True)
b.sort(reverse=True)
for i in range(1, len(a)):
a[i][0] += a[i - 1][0]
for i in range(1, min(len(b), v // 2)):
b[i][0] += b[i - 1][0]
res = [0, 0, 0]
r = range(0, min(v, len(a)) + 1)
for i in r:
j = int(min((v - i) // 2, len(b)))
v1 = 0
if i:
v1 = a[i - 1][0]
v2 = 0
if j:
v2 = b[j - 1][0]
if res[0] < v1 + v2:
res = [v1 + v2, i, j]
print(res[0])
path = []
if res[1]:
for i in range(res[1]):
path.append(a[i][1])
if res[2]:
for i in range(res[2]):
path.append(b[i][1])
print(' '.join(str(i) for i in path))
|
Sereja has an n × m rectangular table a, each cell of the table contains a zero or a number one. Sereja wants his table to meet the following requirement: each connected component of the same values forms a rectangle with sides parallel to the sides of the table. Rectangles should be filled with cells, that is, if a component form a rectangle of size h × w, then the component must contain exactly hw cells.
A connected component of the same values is a set of cells of the table that meet the following conditions:
* every two cells of the set have the same value;
* the cells of the set form a connected region on the table (two cells are connected if they are adjacent in some row or some column of the table);
* it is impossible to add any cell to the set unless we violate the two previous conditions.
Can Sereja change the values of at most k cells of the table so that the table met the described requirement? What minimum number of table cells should he change in this case?
Input
The first line contains integers n, m and k (1 ≤ n, m ≤ 100; 1 ≤ k ≤ 10). Next n lines describe the table a: the i-th of them contains m integers ai1, ai2, ..., aim (0 ≤ ai, j ≤ 1) — the values in the cells of the i-th row.
Output
Print -1, if it is impossible to meet the requirement. Otherwise, print the minimum number of cells which should be changed.
Examples
Input
5 5 2
1 1 1 1 1
1 1 1 1 1
1 1 0 1 1
1 1 1 1 1
1 1 1 1 1
Output
1
Input
3 4 1
1 0 0 0
0 1 1 1
1 1 1 0
Output
-1
Input
3 4 1
1 0 0 1
0 1 1 0
1 0 0 1
Output
0
|
import java.io.*;
import java.util.*;
public class ProblemE {
public static void main(String[] args) throws Exception {
ParserdoubtE in = new ParserdoubtE(System.in);
PrintWriter out = new PrintWriter(System.out);
n = in.nextInt();
m = in.nextInt();
k = in.nextInt();
a = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = in.nextInt();
}
}
int best = 1000;
if(m >= 12) {
for (int fixedRow = 0; fixedRow < n; fixedRow++) {
int sum = 0;
for (int i = 0; i < n; i++) {
int same = 0;
int opposite = 0;
for (int j = 0; j < m; j++) {
if(a[i][j] == a[fixedRow][j]) {
opposite++;
}
else {
same++;
}
}
sum += Math.min(same, opposite);
}
best = Math.min(best, sum);
}
}
else {
for (int mask = 0; mask < 1 << m; mask++) {
int fixedRow[] = new int[m];
for (int j = 0; j < m; j++) {
if((mask & (1 << j)) > 0) {
fixedRow[j] = 1;
}
}
int sum = 0;
for (int i = 0; i < n; i++) {
int same = 0;
int opposite = 0;
for (int j = 0; j < m; j++) {
if(a[i][j] == fixedRow[j]) {
opposite++;
}
else {
same++;
}
}
sum += Math.min(same, opposite);
}
best = Math.min(best, sum);
}
}
// System.out.println("BB " + best);
if(best > k) {
System.out.println("-1");
}
else {
System.out.println(best);
}
}
static int n;
static int m;
static int k;
static int a[][];
}
class ParserdoubtE
{
final private int BUFFER_SIZE = 1 << 17;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public ParserdoubtE(InputStream in)
{
din = new DataInputStream(in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String nextString() throws Exception
{
StringBuffer sb=new StringBuffer("");
byte c = read();
while (c <= ' ') c = read();
do
{
sb.append((char)c);
c=read();
}while(c>' ');
return sb.toString();
}
public char nextChar() throws Exception
{
byte c=read();
while(c<=' ') c= read();
return (char)c;
}
public int nextInt() throws Exception
{
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = c == '-';
if (neg) c = read();
do
{
ret = ret * 10 + c - '0';
c = read();
} while (c > ' ');
if (neg) return -ret;
return ret;
}
public long nextLong() throws Exception
{
long ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = c == '-';
if (neg) c = read();
do
{
ret = ret * 10 + c - '0';
c = read();
} while (c > ' ');
if (neg) return -ret;
return ret;
}
private void fillBuffer() throws Exception
{
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) buffer[0] = -1;
}
private byte read() throws Exception
{
if (bufferPointer == bytesRead) fillBuffer();
return buffer[bufferPointer++];
}
}
|
Berland amusement park shooting gallery is rightly acknowledged as one of the best in the world. Every day the country's best shooters master their skills there and the many visitors compete in clay pigeon shooting to win decent prizes. And the head of the park has recently decided to make an online version of the shooting gallery. During the elaboration process it turned out that the program that imitates the process of shooting effectively, is needed. To formulate the requirements to the program, the shooting gallery was formally described. A 3D Cartesian system of coordinates was introduced, where the X axis ran across the gallery floor along the line, along which the shooters are located, the Y axis ran vertically along the gallery wall and the positive direction of the Z axis matched the shooting direction. Let's call the XOY plane a shooting plane and let's assume that all the bullets are out of the muzzles at the points of this area and fly parallel to the Z axis. Every clay pigeon can be represented as a rectangle whose sides are parallel to X and Y axes, and it has a positive z-coordinate. The distance between a clay pigeon and the shooting plane is always different for every target. The bullet hits the target if it goes through the inner area or border of the rectangle corresponding to it. When the bullet hits the target, the target falls down vertically into the crawl-space of the shooting gallery and cannot be shot at any more. The targets are tough enough, that's why a bullet can not pierce a target all the way through and if a bullet hits a target it can't fly on. In input the simulator program is given the arrangement of all the targets and also of all the shots in the order of their appearance. The program should determine which target was hit by which shot. If you haven't guessed it yet, you are the one who is to write such a program.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of targets. Each of the subsequent n lines contains the description of a target. The target is described by five integers xl, xr, yl, yr, z, that determine it's location in space (0 ≤ xl < xr ≤ 107, 0 ≤ yl < yr ≤ 107, 0 < z ≤ 107). The next line contains an integer m (1 ≤ m ≤ 105), determining the number of shots. Then in m lines shots are described. Every shot is determined by the coordinates of a bullet on the shooting plane (x, y) (0 ≤ x, y ≤ 107, the coordinates of bullets are integers). The shots are given in the order of their firing. The intervals between shots are large enough, and a target falls very quickly, that's why assume that a falling target can not be an obstruction for all the shots following the one that hit it.
Output
For every shot in the single line print the number of the target which the shot has hit, or 0, if the bullet did not hit any target. The targets are numbered starting from 1 in the order in which they were given in the input data.
Examples
Input
2
1 4 1 4 1
2 5 2 6 2
4
0 0
3 3
4 5
3 5
Output
0
1
2
0
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, u, d, z, id;
} a[3001000];
int tr[3001000][2], cnt, pri[3001000], minn[3001000], x[3001000], y[3001000],
root[3001000], ex[3001000], excnt, size, i, n, m, ans[3001000],
anss[3001000];
pair<int, int> v[3001000];
bool cmp(node x, node y) { return x.z < y.z; }
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
void init() {
sort(ex + 1, ex + 1 + excnt);
size = unique(ex + 1, ex + 1 + excnt) - ex - 1;
for (i = 1; i <= n; i++) x[i] = lower_bound(ex + 1, ex + 1 + size, x[i]) - ex;
for (i = 1; i <= m; i++) {
a[i].l = lower_bound(ex + 1, ex + 1 + size, a[i].l) - ex;
a[i].r = lower_bound(ex + 1, ex + 1 + size, a[i].r) - ex;
}
}
int point(int a, int b) {
int o = ++cnt;
pri[o] = rand();
v[o] = make_pair(a, b);
minn[o] = b;
return o;
}
void pushup(int rt) {
minn[rt] = min(min(tr[rt][0] ? minn[tr[rt][0]] : 100000000,
tr[rt][1] ? minn[tr[rt][1]] : 100000000),
v[rt].second);
}
void split(int rt, pair<int, int> k, int &x, int &y) {
if (rt == 0) {
x = 0, y = 0;
return;
}
if (v[rt] <= k)
x = rt, split(tr[rt][1], k, tr[x][1], y);
else
y = rt, split(tr[rt][0], k, x, tr[y][0]);
pushup(rt);
}
int merge(int x, int y) {
if (x == 0 || y == 0) return x + y;
if (pri[x] < pri[y]) {
tr[x][1] = merge(tr[x][1], y);
pushup(x);
return x;
} else {
tr[y][0] = merge(x, tr[y][0]);
pushup(y);
return y;
}
}
void add(int rt, int id) {
int a, c, b = point(y[id], id);
split(root[rt], make_pair(y[id], id - 1), a, c);
root[rt] = merge(merge(a, b), c);
}
void del(int rt, int id) {
int a, b, c;
split(root[rt], make_pair(y[id], id - 1), a, c);
split(c, make_pair(y[id], id), b, c);
root[rt] = merge(a, c);
}
int calc(int rt, int l, int r) {
int a, b, c;
split(root[rt], make_pair(l - 1, 100000000), a, c);
split(c, make_pair(r, 100000000), b, c);
int ret = (b == 0) ? 100000000 : minn[b];
root[rt] = merge(merge(a, b), c);
return ret;
}
void modify(int rt, int l, int r, int x, int id, int f) {
if (f == 1)
add(rt, id);
else
del(rt, id);
if (l == r) return;
if (x <= ((l + r) / 2))
modify((rt << 1), l, ((l + r) / 2), x, id, f);
else
modify((rt << 1 | 1), ((l + r) / 2) + 1, r, x, id, f);
}
void query(int rt, int l, int r, int x, int y, int id) {
if (x <= l && r <= y) {
int tmp = calc(rt, a[id].d, a[id].u);
ans[a[id].id] = min(ans[a[id].id], tmp);
return;
}
if (x <= ((l + r) / 2)) query((rt << 1), l, ((l + r) / 2), x, y, id);
if (y >= ((l + r) / 2) + 1)
query((rt << 1 | 1), ((l + r) / 2) + 1, r, x, y, id);
}
int main() {
srand(20010425);
scanf("%d", &m);
for (i = 1; i <= m; i++) {
a[i].l = read();
a[i].r = read(), a[i].d = read(), a[i].u = read(), a[i].z = read();
a[i].id = i;
ex[++excnt] = a[i].l, ex[++excnt] = a[i].r;
ans[i] = 100000000;
}
sort(a + 1, a + 1 + m, cmp);
scanf("%d", &n);
for (i = 1; i <= n; i++) x[i] = read(), y[i] = read(), ex[++excnt] = x[i];
init();
for (i = 1; i <= n; i++) modify(1, 1, size, x[i], i, 1);
for (i = 1; i <= m; i++) {
query(1, 1, size, a[i].l, a[i].r, i);
if (ans[a[i].id] == 100000000) continue;
modify(1, 1, size, x[ans[a[i].id]], ans[a[i].id], -1);
}
for (i = 1; i <= m; i++)
if (ans[i] != 100000000) anss[ans[i]] = i;
for (i = 1; i <= n; i++) printf("%d\n", anss[i]);
}
|
Polar bears Menshykov and Uslada from the zoo of St. Petersburg and elephant Horace from the zoo of Kiev decided to build a house of cards. For that they've already found a hefty deck of n playing cards. Let's describe the house they want to make:
1. The house consists of some non-zero number of floors.
2. Each floor consists of a non-zero number of rooms and the ceiling. A room is two cards that are leaned towards each other. The rooms are made in a row, each two adjoining rooms share a ceiling made by another card.
3. Each floor besides for the lowest one should contain less rooms than the floor below.
Please note that the house may end by the floor with more than one room, and in this case they also must be covered by the ceiling. Also, the number of rooms on the adjoining floors doesn't have to differ by one, the difference may be more.
While bears are practicing to put cards, Horace tries to figure out how many floors their house should consist of. The height of the house is the number of floors in it. It is possible that you can make a lot of different houses of different heights out of n cards. It seems that the elephant cannot solve this problem and he asks you to count the number of the distinct heights of the houses that they can make using exactly n cards.
Input
The single line contains integer n (1 ≤ n ≤ 1012) — the number of cards.
Output
Print the number of distinct heights that the houses made of exactly n cards can have.
Examples
Input
13
Output
1
Input
6
Output
0
Note
In the first sample you can build only these two houses (remember, you must use all the cards):
<image>
Thus, 13 cards are enough only for two floor houses, so the answer is 1.
The six cards in the second sample are not enough to build any house.
|
import java.io.*;
import java.util.*;
public class P3 {
public static void main (String[] args) {
Scanner sc = new Scanner (System.in);
PrintStream op = System.out;
int count = 0;
long n = sc.nextLong();
int a = 0, b = 0;
switch ((int)(n % 3)) {
case 0: {
a = 15; b = 42;
break;
}
case 1: {
a = 7; b = 33;
break;
}
case 2: {
a = 2; b = 24;
break;
}
default: break;
}
for (long i = a, val = b; i <= n; i += val, val += 27)
count++;
op.println(count);
sc.close();
}
}
|
Hamed has recently found a string t and suddenly became quite fond of it. He spent several days trying to find all occurrences of t in other strings he had. Finally he became tired and started thinking about the following problem. Given a string s how many ways are there to extract k ≥ 1 non-overlapping substrings from it such that each of them contains string t as a substring? More formally, you need to calculate the number of ways to choose two sequences a1, a2, ..., ak and b1, b2, ..., bk satisfying the following requirements:
* k ≥ 1
* <image>
* <image>
* <image>
* <image> t is a substring of string saisai + 1... sbi (string s is considered as 1-indexed).
As the number of ways can be rather large print it modulo 109 + 7.
Input
Input consists of two lines containing strings s and t (1 ≤ |s|, |t| ≤ 105). Each string consists of lowercase Latin letters.
Output
Print the answer in a single line.
Examples
Input
ababa
aba
Output
5
Input
welcometoroundtwohundredandeightytwo
d
Output
274201
Input
ddd
d
Output
12
|
#include <bits/stdc++.h>
char s[100010], t[100010];
int next[100010], occ[100010], n = 0, lens, lent;
long long f[100010], g[100010];
int main() {
scanf("%s%s", s, t), lens = strlen(s), lent = strlen(t);
next[0] = next[1] = 0;
for (int i = 1, j; i < lent; i++) {
j = next[i];
while (j && t[i] != t[j]) j = next[j];
next[i + 1] = (t[i] == t[j] ? j + 1 : 0);
}
for (int i = 0, cur = -1; i < lens; i++) {
if (cur == -1 && s[i] == t[0])
cur = 0;
else {
while (cur >= 0 && s[i] != t[cur + 1]) cur = next[cur + 1] - 1;
if (cur == -1 && s[i] == t[0])
cur = 0;
else if (s[i] == t[cur + 1])
cur++;
}
if (cur == lent - 1) occ[n++] = i - lent + 2, cur = next[cur + 1] - 1;
}
f[0] = g[0] = 1;
for (int i = 1, last = 0, cur = 0; i <= lens; i++) {
if (cur < n && occ[cur] + lent - 1 == i) last = i - lent + 1, cur++;
f[i] = (f[i - 1] + (last ? g[last - 1] : 0)) % 1000000007;
g[i] = (g[i - 1] + f[i]) % 1000000007;
}
printf("%I64d\n", ((f[lens] - 1) % 1000000007 + 1000000007) % 1000000007);
return 0;
}
|
In this problem is used an extremely simplified version of HTML table markup. Please use the statement as a formal document and read it carefully.
A string is a bHTML table, if it satisfies the grammar:
TABLE ::= <table>ROWS</table>
ROWS ::= ROW | ROW ROWS
ROW ::= <tr>CELLS</tr>
CELLS ::= CELL | CELL CELLS
CELL ::= <td></td> | <td>TABLE</td>
Blanks in the grammar are only for purposes of illustration, in the given data there will be no spaces. The bHTML table is very similar to a simple regular HTML table in which meet only the following tags : "table", "tr", "td", all the tags are paired and the table contains at least one row and at least one cell in each row. Have a look at the sample tests as examples of tables.
As can be seen, the tables may be nested. You are given a table (which may contain other(s)). You need to write a program that analyzes all the tables and finds the number of cells in each of them. The tables are not required to be rectangular.
Input
For convenience, input data can be separated into non-empty lines in an arbitrary manner. The input data consist of no more than 10 lines. Combine (concatenate) all the input lines into one, to get a text representation s of the specified table. String s corresponds to the given grammar (the root element of grammar is TABLE), its length does not exceed 5000. Only lower case letters are used to write tags. There are no spaces in the given string s.
Output
Print the sizes of all the tables in the non-decreasing order.
Examples
Input
<table><tr><td></td></tr></table>
Output
1
Input
<table>
<tr>
<td>
<table><tr><td></td></tr><tr><td></
td
></tr><tr
><td></td></tr><tr><td></td></tr></table>
</td>
</tr>
</table>
Output
1 4
Input
<table><tr><td>
<table><tr><td>
<table><tr><td>
<table><tr><td></td><td></td>
</tr><tr><td></td></tr></table>
</td></tr></table>
</td></tr></table>
</td></tr></table>
Output
1 1 1 3
|
#include <bits/stdc++.h>
using namespace std;
int n, ans, a[10000], cnt, _prev[10000], cur;
string s;
bool comp(int st, string t) {
for (int i = 0; i < (int)t.length(); i++)
if (s[st + i] != t[i]) return false;
return true;
}
void inc() {
int i = cur;
while (i) {
a[i]++;
i = _prev[i];
}
a[0]++;
}
int main() {
string t;
while (cin >> t) s += t;
for (int i = 0; i < (int)s.length();)
if (comp(i, "<table>")) {
_prev[cnt] = cur;
cur = cnt++;
i += 7;
} else if (comp(i, "</table>")) {
cur = _prev[cur];
i += 8;
} else if (comp(i, "<tr>"))
i += 4;
else if (comp(i, "</tr>"))
i += 5;
else if (comp(i, "<td>")) {
a[cur]++;
i += 4;
} else if (comp(i, "</td>"))
i += 5;
sort(a, a + cnt);
for (int i = 0; i < cnt; i++) cout << a[i] << " ";
return 0;
}
|
Two bored soldiers are playing card war. Their card deck consists of exactly n cards, numbered from 1 to n, all values are different. They divide cards between them in some manner, it's possible that they have different number of cards. Then they play a "war"-like card game.
The rules are following. On each turn a fight happens. Each of them picks card from the top of his stack and puts on the table. The one whose card value is bigger wins this fight and takes both cards from the table to the bottom of his stack. More precisely, he first takes his opponent's card and puts to the bottom of his stack, and then he puts his card to the bottom of his stack. If after some turn one of the player's stack becomes empty, he loses and the other one wins.
You have to calculate how many fights will happen and who will win the game, or state that game won't end.
Input
First line contains a single integer n (2 ≤ n ≤ 10), the number of cards.
Second line contains integer k1 (1 ≤ k1 ≤ n - 1), the number of the first soldier's cards. Then follow k1 integers that are the values on the first soldier's cards, from top to bottom of his stack.
Third line contains integer k2 (k1 + k2 = n), the number of the second soldier's cards. Then follow k2 integers that are the values on the second soldier's cards, from top to bottom of his stack.
All card values are different.
Output
If somebody wins in this game, print 2 integers where the first one stands for the number of fights before end of game and the second one is 1 or 2 showing which player has won.
If the game won't end and will continue forever output - 1.
Examples
Input
4
2 1 3
2 4 2
Output
6 2
Input
3
1 2
2 1 3
Output
-1
Note
First sample:
<image>
Second sample:
<image>
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x;
cin >> n;
long long k1, k2;
vector<long long> v1, v2, v3, v4;
cin >> k1;
for (int i = 0; i < k1; i++) {
cin >> x;
v1.push_back(x);
v3.push_back(x);
}
cin >> k2;
for (int i = 0; i < k2; i++) {
cin >> x;
v2.push_back(x);
v4.push_back(x);
}
long long ans = 0, f = -1;
while (1) {
if (v1.size() == 0) {
f = 2;
break;
} else if (v2.size() == 0) {
f = 1;
break;
} else {
bool mf = 1, mf1 = 1;
for (int i = 0; i < v1.size(); i++) {
if (v1[i] != v3[i]) {
mf = 0;
break;
}
}
for (int i = 0; i < v2.size(); i++) {
if (v2[i] != v4[i]) {
mf1 = 0;
break;
}
}
if (ans > 1 && mf == 1 && mf1 == 1 && (v1.size() == v3.size()) &&
(v2.size() == v4.size())) {
f = -1;
break;
} else if (ans > 10000000)
break;
if (v1[0] > v2[0]) {
v1.push_back(v2[0]);
v1.push_back(v1[0]);
v1.erase(v1.begin());
v2.erase(v2.begin());
ans++;
} else {
v2.push_back(v1[0]);
v2.push_back(v2[0]);
v1.erase(v1.begin());
v2.erase(v2.begin());
ans++;
}
}
}
if (f == -1)
cout << -1 << endl;
else
cout << ans << " " << f << endl;
}
|
'In Boolean logic, a formula is in conjunctive normal form (CNF) or clausal normal form if it is a conjunction of clauses, where a clause is a disjunction of literals' (cited from https://en.wikipedia.org/wiki/Conjunctive_normal_form)
In the other words, CNF is a formula of type <image>, where & represents a logical "AND" (conjunction), <image> represents a logical "OR" (disjunction), and vij are some boolean variables or their negations. Each statement in brackets is called a clause, and vij are called literals.
You are given a CNF containing variables x1, ..., xm and their negations. We know that each variable occurs in at most two clauses (with negation and without negation in total). Your task is to determine whether this CNF is satisfiable, that is, whether there are such values of variables where the CNF value is true. If CNF is satisfiable, then you also need to determine the values of the variables at which the CNF is true.
It is guaranteed that each variable occurs at most once in each clause.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 2·105) — the number of clauses and the number variables, correspondingly.
Next n lines contain the descriptions of each clause. The i-th line first contains first number ki (ki ≥ 1) — the number of literals in the i-th clauses. Then follow space-separated literals vij (1 ≤ |vij| ≤ m). A literal that corresponds to vij is x|vij| either with negation, if vij is negative, or without negation otherwise.
Output
If CNF is not satisfiable, print a single line "NO" (without the quotes), otherwise print two strings: string "YES" (without the quotes), and then a string of m numbers zero or one — the values of variables in satisfying assignment in the order from x1 to xm.
Examples
Input
2 2
2 1 -2
2 2 -1
Output
YES
11
Input
4 3
1 1
1 2
3 -1 -2 3
1 -3
Output
NO
Input
5 6
2 1 2
3 1 -2 3
4 -3 5 4 6
2 -6 -4
1 5
Output
YES
100010
Note
In the first sample test formula is <image>. One of possible answer is x1 = TRUE, x2 = TRUE.
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int n, m, l, a;
int idx[400005][2];
vector<int> model;
vector<vector<int> > clauses;
vector<bool> satisfied;
int cntDetermined;
stack<pair<vector<int>, vector<int> > > st;
bool isDeterministic(int i) {
int k = idx[i][0];
if (i > m) i -= m;
for (int l = 0; l < (int)clauses[k].size(); l++) {
int ii = clauses[k][l];
if (abs(ii) == i) continue;
if (model[abs(ii)] == -1) return 0;
}
return 1;
}
void findModel(int i);
void updateSatisfied(int i) {
satisfied[i] = 1;
for (int j = 0; j < (int)clauses[i].size(); j++) {
int next = clauses[i][j];
if (model[abs(next)] == -1) {
if (next < 0) next = abs(next) + m;
if (idx[next][0] == i)
idx[next][0] = idx[next][1];
else
idx[next][1] = -1;
if (idx[next][0] == -1) {
if (next > m) next -= m;
findModel(next);
}
}
}
}
void findModel(int i) {
if (idx[i][0] == -1 && idx[i + m][0] == -1) {
model[i] = 1;
cntDetermined++;
return;
} else if (idx[i][0] == -1) {
model[i] = 0;
cntDetermined++;
if (satisfied[idx[i + m][0]] == 0) updateSatisfied(idx[i + m][0]);
if (idx[i + m][1] != -1 && satisfied[idx[i + m][1]] == 0)
updateSatisfied(idx[i + m][1]);
} else if (idx[i + m][0] == -1) {
model[i] = 1;
cntDetermined++;
if (satisfied[idx[i][0]] == 0) updateSatisfied(idx[i][0]);
if (idx[i][1] != -1 && satisfied[idx[i][1]] == 0)
updateSatisfied(idx[i][1]);
} else {
if (satisfied[idx[i][0]] && satisfied[idx[i + m][0]]) {
model[i] = 1;
cntDetermined++;
return;
} else if (satisfied[idx[i][0]]) {
model[i] = 0;
cntDetermined++;
updateSatisfied(idx[i + m][0]);
return;
} else if (satisfied[idx[i + m][0]]) {
model[i] = 1;
cntDetermined++;
updateSatisfied(idx[i][0]);
return;
}
bool determined = isDeterministic(i);
if (determined) {
model[i] = 1;
cntDetermined++;
if (satisfied[idx[i][0]] == 0) updateSatisfied(idx[i][0]);
return;
}
determined = isDeterministic(i + m);
if (determined) {
model[i] = 0;
cntDetermined++;
if (satisfied[idx[i + m][0]] == 0) updateSatisfied(idx[i + m][0]);
return;
}
}
}
void findModel(int i, vector<int>& idx1, vector<int>& idx2);
void updateSatisfied(int i, vector<int>& idx1, vector<int>& idx2) {
satisfied[i] = 1;
idx2.push_back(i);
for (int j = 0; j < (int)clauses[i].size(); j++) {
int next = clauses[i][j];
if (model[abs(next)] == -1) {
if (next < 0) next = abs(next) + m;
if (idx[next][0] == i)
idx[next][0] = idx[next][1];
else
idx[next][1] = -1;
if (idx[next][0] == -1) {
if (next > m) next -= m;
findModel(next, idx1, idx2);
}
}
}
}
void findModel(int i, vector<int>& idx1, vector<int>& idx2) {
if (idx[i][0] == -1 && idx[i + m][0] == -1) {
model[i] = 1;
idx1.push_back(i);
cntDetermined++;
return;
} else if (idx[i][0] == -1) {
model[i] = 0;
idx1.push_back(i);
cntDetermined++;
if (satisfied[idx[i + m][0]] == 0)
updateSatisfied(idx[i + m][0], idx1, idx2);
if (idx[i + m][1] != -1 && satisfied[idx[i + m][1]] == 0)
updateSatisfied(idx[i + m][1], idx1, idx2);
} else if (idx[i + m][0] == -1) {
model[i] = 1;
idx1.push_back(i);
cntDetermined++;
if (satisfied[idx[i][0]] == 0) updateSatisfied(idx[i][0], idx1, idx2);
if (idx[i][1] != -1 && satisfied[idx[i][1]] == 0)
updateSatisfied(idx[i][1], idx1, idx2);
} else {
if (satisfied[idx[i][0]] && satisfied[idx[i + m][0]]) {
model[i] = 1;
idx1.push_back(i);
cntDetermined++;
return;
} else if (satisfied[idx[i][0]]) {
model[i] = 0;
idx1.push_back(i);
cntDetermined++;
updateSatisfied(idx[i + m][0], idx1, idx2);
return;
} else if (satisfied[idx[i + m][0]]) {
model[i] = 1;
idx1.push_back(i);
cntDetermined++;
updateSatisfied(idx[i][0], idx1, idx2);
return;
}
bool determined = isDeterministic(i);
if (determined) {
model[i] = 1;
idx1.push_back(i);
cntDetermined++;
if (satisfied[idx[i][0]] == 0) updateSatisfied(idx[i][0], idx1, idx2);
return;
}
determined = isDeterministic(i + m);
if (determined) {
model[i] = 0;
idx1.push_back(i);
cntDetermined++;
if (satisfied[idx[i + m][0]] == 0)
updateSatisfied(idx[i + m][0], idx1, idx2);
return;
}
}
}
bool isCorrectModel() {
for (int i = 0; i < (int)n; i++) {
bool possible = false;
for (int j = 0; j < (int)clauses[i].size(); j++) {
int ii = clauses[i][j];
if (ii > 0 && model[ii] == 1) {
possible = true;
break;
} else if (ii < 0 && model[-ii] == 0) {
possible = true;
break;
}
}
if (!possible) return false;
}
return true;
}
bool fullSearch(int lim) {
if (cntDetermined == m) {
if (isCorrectModel()) {
return true;
}
return false;
}
for (int j = lim; j < (int)m + 1; j++) {
if (model[j] == -1) {
for (int k = 0; k < (int)2; k++) {
vector<int> idx1, idx2;
model[j] = k;
cntDetermined++;
if (satisfied[idx[j + m * (1 - k)][0]] == 0) {
satisfied[idx[j + m * (1 - k)][0]] = 1;
idx2.push_back(idx[j + m * (1 - k)][0]);
}
idx1.push_back(j);
while (1) {
int cnt = cntDetermined;
bool next = false;
for (int i = 1; i < (int)m + 1; i++) {
if (model[i] == -1) {
next = true;
findModel(i, idx1, idx2);
}
}
if (cnt == cntDetermined) break;
if (!next) break;
}
st.push(make_pair(idx1, idx2));
if (fullSearch(j + 1))
return true;
else {
vector<int> idx1 = st.top().first, idx2 = st.top().second;
st.pop();
cntDetermined -= idx1.size();
for (int l = 0; l < (int)idx1.size(); l++) model[idx1[l]] = -1;
for (int l = 0; l < (int)idx2.size(); l++) satisfied[idx2[l]] = 0;
continue;
}
}
return false;
}
}
}
int main() {
scanf("%d%d", &n, &m);
model.resize(m + 1, -1);
memset(idx, -1, sizeof(idx));
for (int i = 0; i < (int)n; i++) {
scanf("%d", &l);
vector<int> clause(l);
for (int j = 0; j < (int)l; j++) {
scanf("%d", &a);
clause[j] = a;
if (a < 0) a = abs(a) + m;
if (idx[a][0] == -1)
idx[a][0] = i;
else
idx[a][1] = i;
}
clauses.push_back(clause);
}
satisfied.resize(n, 0);
cntDetermined = 0;
int lim = 1;
while (1) {
int cnt = cntDetermined;
bool next = false;
int lim1 = -1;
for (int i = lim; i < (int)m + 1; i++) {
if (model[i] == -1) {
next = true;
findModel(i);
}
if (model[i] == -1 && lim1 == -1) lim1 = i;
}
lim = lim1;
if (cnt == cntDetermined) break;
if (!next) break;
}
if (cntDetermined != m) {
fullSearch(1);
}
if (!isCorrectModel())
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i < (int)m + 1; i++) printf("%d", model[i]);
printf("\n");
}
return 0;
}
|
Edo has got a collection of n refrigerator magnets!
He decided to buy a refrigerator and hang the magnets on the door. The shop can make the refrigerator with any size of the door that meets the following restrictions: the refrigerator door must be rectangle, and both the length and the width of the door must be positive integers.
Edo figured out how he wants to place the magnets on the refrigerator. He introduced a system of coordinates on the plane, where each magnet is represented as a rectangle with sides parallel to the coordinate axes.
Now he wants to remove no more than k magnets (he may choose to keep all of them) and attach all remaining magnets to the refrigerator door, and the area of the door should be as small as possible. A magnet is considered to be attached to the refrigerator door if its center lies on the door or on its boundary. The relative positions of all the remaining magnets must correspond to the plan.
Let us explain the last two sentences. Let's suppose we want to hang two magnets on the refrigerator. If the magnet in the plan has coordinates of the lower left corner (x1, y1) and the upper right corner (x2, y2), then its center is located at (<image>, <image>) (may not be integers). By saying the relative position should correspond to the plan we mean that the only available operation is translation, i.e. the vector connecting the centers of two magnets in the original plan, must be equal to the vector connecting the centers of these two magnets on the refrigerator.
The sides of the refrigerator door must also be parallel to coordinate axes.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100 000, 0 ≤ k ≤ min(10, n - 1)) — the number of magnets that Edo has and the maximum number of magnets Edo may not place on the refrigerator.
Next n lines describe the initial plan of placing magnets. Each line contains four integers x1, y1, x2, y2 (1 ≤ x1 < x2 ≤ 109, 1 ≤ y1 < y2 ≤ 109) — the coordinates of the lower left and upper right corners of the current magnet. The magnets can partially overlap or even fully coincide.
Output
Print a single integer — the minimum area of the door of refrigerator, which can be used to place at least n - k magnets, preserving the relative positions.
Examples
Input
3 1
1 1 2 2
2 2 3 3
3 3 4 4
Output
1
Input
4 1
1 1 2 2
1 9 2 10
9 9 10 10
9 1 10 2
Output
64
Input
3 0
1 1 2 2
1 1 1000000000 1000000000
1 3 8 12
Output
249999999000000001
Note
In the first test sample it is optimal to remove either the first or the third magnet. If we remove the first magnet, the centers of two others will lie at points (2.5, 2.5) and (3.5, 3.5). Thus, it is enough to buy a fridge with door width 1 and door height 1, the area of the door also equals one, correspondingly.
In the second test sample it doesn't matter which magnet to remove, the answer will not change — we need a fridge with door width 8 and door height 8.
In the third sample you cannot remove anything as k = 0.
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
vector<pll> xs, ys;
for (int i = 0; i < n; ++i) {
ll a, b, c, d;
cin >> a >> b >> c >> d;
xs.emplace_back(a + c, i);
ys.emplace_back(b + d, i);
}
sort((xs).begin(), (xs).end());
sort((ys).begin(), (ys).end());
long long ans = -1;
for (int a = 0; a <= k; ++a) {
for (int b = 0; b <= k; ++b) {
for (int c = 0; c <= k; ++c) {
for (int d = 0; d <= k; ++d) {
set<int> rem;
for (int i = 0; i < a; ++i) rem.insert(xs[i].second);
for (int i = 0; i < b; ++i) rem.insert(xs[n - 1 - i].second);
for (int i = 0; i < c; ++i) rem.insert(ys[i].second);
for (int i = 0; i < d; ++i) rem.insert(ys[n - 1 - i].second);
if ((int)rem.size() > k) continue;
ll w = (xs[n - 1 - b].first - xs[a].first + 1LL) / 2LL;
ll h = (ys[n - 1 - d].first - ys[c].first + 1LL) / 2LL;
ans = min(ans, max(1ll, w) * max(1ll, h));
if (ans == -1) ans = max(1ll, w) * max(1ll, h);
}
}
}
}
cout << ans << '\n';
return 0;
}
|
You are given two very long integers a, b (leading zeroes are allowed). You should check what number a or b is greater or determine that they are equal.
The input size is very large so don't use the reading of symbols one by one. Instead of that use the reading of a whole line or token.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java. Don't use the function input() in Python2 instead of it use the function raw_input().
Input
The first line contains a non-negative integer a.
The second line contains a non-negative integer b.
The numbers a, b may contain leading zeroes. Each of them contains no more than 106 digits.
Output
Print the symbol "<" if a < b and the symbol ">" if a > b. If the numbers are equal print the symbol "=".
Examples
Input
9
10
Output
<
Input
11
10
Output
>
Input
00012345
12345
Output
=
Input
0123
9
Output
>
Input
0123
111
Output
>
|
a = input()
b = input()
if len(a)>len(b):
gap = len(a)-len(b)
new = ''
for _ in range(gap):
new+='0'
b = new + b
elif len(b)>len(a):
gap = len(b) - len(a)
new = ''
for _ in range(gap):
new+='0'
a = new + a
for i in range(0,len(a)):
if(a[i]>b[i]):
print('>')
exit()
elif(b[i]>a[i]):
print('<')
exit()
print('=')
|
A remote island chain contains n islands, labeled 1 through n. Bidirectional bridges connect the islands to form a simple cycle — a bridge connects islands 1 and 2, islands 2 and 3, and so on, and additionally a bridge connects islands n and 1. The center of each island contains an identical pedestal, and all but one of the islands has a fragile, uniquely colored statue currently held on the pedestal. The remaining island holds only an empty pedestal.
The islanders want to rearrange the statues in a new order. To do this, they repeat the following process: First, they choose an island directly adjacent to the island containing an empty pedestal. Then, they painstakingly carry the statue on this island across the adjoining bridge and place it on the empty pedestal.
Determine if it is possible for the islanders to arrange the statues in the desired order.
Input
The first line contains a single integer n (2 ≤ n ≤ 200 000) — the total number of islands.
The second line contains n space-separated integers ai (0 ≤ ai ≤ n - 1) — the statue currently placed on the i-th island. If ai = 0, then the island has no statue. It is guaranteed that the ai are distinct.
The third line contains n space-separated integers bi (0 ≤ bi ≤ n - 1) — the desired statues of the ith island. Once again, bi = 0 indicates the island desires no statue. It is guaranteed that the bi are distinct.
Output
Print "YES" (without quotes) if the rearrangement can be done in the existing network, and "NO" otherwise.
Examples
Input
3
1 0 2
2 0 1
Output
YES
Input
2
1 0
0 1
Output
YES
Input
4
1 2 3 0
0 3 2 1
Output
NO
Note
In the first sample, the islanders can first move statue 1 from island 1 to island 2, then move statue 2 from island 3 to island 1, and finally move statue 1 from island 2 to island 3.
In the second sample, the islanders can simply move statue 1 from island 1 to island 2.
In the third sample, no sequence of movements results in the desired position.
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> a;
int b[200005];
int main() {
int n, x;
scanf("%d", &n);
int j = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
if (x > 0) a[x] = j++;
}
int flag = 1, temp, k = 0;
scanf("%d", &x);
temp = (a[x] + 1) % j;
for (int i = 1; i < n; i++) {
scanf("%d", &x);
if (x > 0) {
if (temp != a[x]) flag = 0;
temp = (a[x] + 1) % j;
b[k++] = x;
}
}
if (!flag) {
for (int i = 0; i < k; i++) {
if (a[b[i]] != i)
break;
else if (i == k - 1 && a[b[i]] == i)
flag = 1;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
|
Greatest common divisor GCD(a, b) of two positive integers a and b is equal to the biggest integer d such that both integers a and b are divisible by d. There are many efficient algorithms to find greatest common divisor GCD(a, b), for example, Euclid algorithm.
Formally, find the biggest integer d, such that all integers a, a + 1, a + 2, ..., b are divisible by d. To make the problem even more complicated we allow a and b to be up to googol, 10100 — such number do not fit even in 64-bit integer type!
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10100).
Output
Output one integer — greatest common divisor of all integers from a to b inclusive.
Examples
Input
1 2
Output
1
Input
61803398874989484820458683436563811772030917980576 61803398874989484820458683436563811772030917980576
Output
61803398874989484820458683436563811772030917980576
|
a,b=map(int,input().split())
print(a) if a==b else print(1)
|
Today Pari and Arya are playing a game called Remainders.
Pari chooses two positive integer x and k, and tells Arya k but not x. Arya have to find the value <image>. There are n ancient numbers c1, c2, ..., cn and Pari has to tell Arya <image> if Arya wants. Given k and the ancient values, tell us if Arya has a winning strategy independent of value of x or not. Formally, is it true that Arya can understand the value <image> for any positive integer x?
Note, that <image> means the remainder of x after dividing it by y.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 1 000 000) — the number of ancient integers and value k that is chosen by Pari.
The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 1 000 000).
Output
Print "Yes" (without quotes) if Arya has a winning strategy independent of value of x, or "No" (without quotes) otherwise.
Examples
Input
4 5
2 3 5 12
Output
Yes
Input
2 7
2 3
Output
No
Note
In the first sample, Arya can understand <image> because 5 is one of the ancient numbers.
In the second sample, Arya can't be sure what <image> is. For example 1 and 7 have the same remainders after dividing by 2 and 3, but they differ in remainders after dividing by 7.
|
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class D {
//private static Scanner in = new Scanner(System.in);
private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
private static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
private static int gcd(int a, int b) {
int t;
while (b > 0) {
t = b;
b = a%b;
a = t;
}
return a;
}
private static int lcm(int a, int b) {
int g = gcd(a, b);
return a/g*b;
}
public static void main(String[] args) throws IOException {
String[] s = in.readLine().split(" ");
int n = Integer.parseInt(s[0]);
int k = Integer.parseInt(s[1]);
s = in.readLine().split(" ");
int ans = 1;
for (int i = 0; i < n; ++i)
ans = lcm(ans, gcd(k, Integer.parseInt(s[i])));
out.println(ans == k ? "Yes" : "No");
out.flush();
}
}
|
Find an n × n matrix with different numbers from 1 to n2, so the sum in each row, column and both main diagonals are odd.
Input
The only line contains odd integer n (1 ≤ n ≤ 49).
Output
Print n lines with n integers. All the integers should be different and from 1 to n2. The sum in each row, column and both main diagonals should be odd.
Examples
Input
1
Output
1
Input
3
Output
2 1 4
3 5 7
6 9 8
|
n = int(input())
if n==1:
print(1)
exit()
odd = 1
evn = 2
table = [[0 for i in range(n)] for i in range(n)]
#(x,y) x row, y col
for x in range(n):
for y in range(n):
x1 = min(x, n-1-x)
if y < (n - 1)/2-x1 or y > (n - 1)/2+x1: #even con
table[x][y] = evn
evn += 2
else:
table[x][y] = odd
odd += 2
for x in table:
for y in x:
print(y, end=" ")
print()
|
Arseniy is already grown-up and independent. His mother decided to leave him alone for m days and left on a vacation. She have prepared a lot of food, left some money and washed all Arseniy's clothes.
Ten minutes before her leave she realized that it would be also useful to prepare instruction of which particular clothes to wear on each of the days she will be absent. Arseniy's family is a bit weird so all the clothes is enumerated. For example, each of Arseniy's n socks is assigned a unique integer from 1 to n. Thus, the only thing his mother had to do was to write down two integers li and ri for each of the days — the indices of socks to wear on the day i (obviously, li stands for the left foot and ri for the right). Each sock is painted in one of k colors.
When mother already left Arseniy noticed that according to instruction he would wear the socks of different colors on some days. Of course, that is a terrible mistake cause by a rush. Arseniy is a smart boy, and, by some magical coincidence, he posses k jars with the paint — one for each of k colors.
Arseniy wants to repaint some of the socks in such a way, that for each of m days he can follow the mother's instructions and wear the socks of the same color. As he is going to be very busy these days he will have no time to change the colors of any socks so he has to finalize the colors now.
The new computer game Bota-3 was just realised and Arseniy can't wait to play it. What is the minimum number of socks that need their color to be changed in order to make it possible to follow mother's instructions and wear the socks of the same color during each of m days.
Input
The first line of input contains three integers n, m and k (2 ≤ n ≤ 200 000, 0 ≤ m ≤ 200 000, 1 ≤ k ≤ 200 000) — the number of socks, the number of days and the number of available colors respectively.
The second line contain n integers c1, c2, ..., cn (1 ≤ ci ≤ k) — current colors of Arseniy's socks.
Each of the following m lines contains two integers li and ri (1 ≤ li, ri ≤ n, li ≠ ri) — indices of socks which Arseniy should wear during the i-th day.
Output
Print one integer — the minimum number of socks that should have their colors changed in order to be able to obey the instructions and not make people laugh from watching the socks of different colors.
Examples
Input
3 2 3
1 2 3
1 2
2 3
Output
2
Input
3 2 2
1 1 2
1 2
2 1
Output
0
Note
In the first sample, Arseniy can repaint the first and the third socks to the second color.
In the second sample, there is no need to change any colors.
|
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.LinkedList;
public class C {
private static class Node {
LinkedList<Node> childs = new LinkedList<>();
int col;
boolean visited = false;
public Node(int col) {
this.col = col;
}
}
public static void main(String args[]) {
Sc sc = new Sc(System.in);
int n = sc.nI();
int m = sc.nI();
int k = sc.nI();
Node[] socks = new Node[n];
for(int i = 0; i<n; i++) {
socks[i] = new Node(sc.nI());
}
for(int i = 0; i<m; i++) {
int l = sc.nI() - 1;
int r = sc.nI() - 1;
socks[l].childs.add(socks[r]);
socks[r].childs.add(socks[l]);
}
int change = 0;
for(int i = 0; i<n; i++) {
if(socks[i].visited) continue;
HashMap<Integer, Integer> map = new HashMap<>();
int sum = 1;
int max = 1;
map.put(socks[i].col,1);
LinkedList<Node> active = new LinkedList<>();
active.add(socks[i]);
socks[i].visited = true;
while(!active.isEmpty()) {
Node nod = active.pollFirst();
for(Node ch: nod.childs) {
if(ch.visited) continue;
ch.visited = true;
active.addLast(ch);
if(map.containsKey(ch.col)) map.put(ch.col, map.get(ch.col) + 1);
else map.put(ch.col,1);
sum++;
max = Math.max(max, map.get(ch.col));
}
}
change += sum - max;
}
System.out.println(change);
}
}
class Sc {
public Sc(InputStream i) {
r = new BufferedReader(new InputStreamReader(i));
}
public boolean hasM() {
return peekToken() != null;
}
public int nI() {
return Integer.parseInt(nextToken());
}
public double nD() {
return Double.parseDouble(nextToken());
}
public long nL() {
return Long.parseLong(nextToken());
}
public String n() {
return nextToken();
}
private BufferedReader r;
private String line;
private StringTokenizer st;
private String token;
private String peekToken() {
if (token == null)
try {
while (st == null || !st.hasMoreTokens()) {
line = r.readLine();
if (line == null) return null;
st = new StringTokenizer(line);
}
token = st.nextToken();
} catch (IOException e) { }
return token;
}
private String nextToken() {
String ans = peekToken();
token = null;
return ans;
}
}
|
PolandBall has an undirected simple graph consisting of n vertices. Unfortunately, it has no edges. The graph is very sad because of that. PolandBall wanted to make it happier, adding some red edges. Then, he will add white edges in every remaining place. Therefore, the final graph will be a clique in two colors: white and red.
Colorfulness of the graph is a value min(dr, dw), where dr is the diameter of the red subgraph and dw is the diameter of white subgraph. The diameter of a graph is a largest value d such that shortest path between some pair of vertices in it is equal to d. If the graph is not connected, we consider its diameter to be -1.
PolandBall wants the final graph to be as neat as possible. He wants the final colorfulness to be equal to k. Can you help him and find any graph which satisfies PolandBall's requests?
Input
The only one input line contains two integers n and k (2 ≤ n ≤ 1000, 1 ≤ k ≤ 1000), representing graph's size and sought colorfulness.
Output
If it's impossible to find a suitable graph, print -1.
Otherwise, you can output any graph which fulfills PolandBall's requirements. First, output m — the number of red edges in your graph. Then, you should output m lines, each containing two integers ai and bi, (1 ≤ ai, bi ≤ n, ai ≠ bi) which means that there is an undirected red edge between vertices ai and bi. Every red edge should be printed exactly once, you can print the edges and the vertices of every edge in arbitrary order.
Remember that PolandBall's graph should remain simple, so no loops or multiple edges are allowed.
Examples
Input
4 1
Output
-1
Input
5 2
Output
4
1 2
2 3
3 4
4 5
Note
In the first sample case, no graph can fulfill PolandBall's requirements.
In the second sample case, red graph is a path from 1 to 5. Its diameter is 4. However, white graph has diameter 2, because it consists of edges 1-3, 1-4, 1-5, 2-4, 2-5, 3-5.
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1017;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
if (k > 3) return cout << -1 << '\n', 0;
if (k == 1) return cout << -1 << '\n', 0;
if (k == 2 && n <= 4) return cout << -1 << '\n', 0;
if (k == 3 && n <= 3) return cout << -1 << '\n', 0;
if (k == 2) {
cout << n - 1 << '\n';
for (int i = 1; i < n; i++) cout << i << ' ' << i + 1 << '\n';
return 0;
} else if (k == 3) {
cout << n - 1 << '\n';
for (int i = 2; i < n; i++) cout << 1 << ' ' << i << '\n';
cout << 2 << ' ' << n << '\n';
return 0;
}
}
|
Sherlock met Moriarty for a final battle of wits. He gave him a regular n sided convex polygon. In addition to it, he gave him certain diagonals to form regions on the polygon. It was guaranteed that the diagonals did not intersect in interior points.
He took each of the region and calculated its importance value. Importance value for a region formed by vertices a1, a2, ... , ax of the polygon will be given by 2a1 + 2a2 + ... + 2ax. Then, he sorted these regions on the basis of their importance value in ascending order. After that he assigned each region an index from 1 to k, where k is the number of regions, and index of region is its position in the sorted array calculated above.
He wants Moriarty to color the regions using not more than 20 colors, such that two regions have same color only if all the simple paths between these two regions have at least one region with color value less than the color value assigned to these regions. Simple path between two regions f and h is a sequence of regions r1, r2, ... rt such that r1 = f, rt = h, for each 1 ≤ i < t regions ri and ri + 1 share an edge, and ri = rj if and only if i = j.
Moriarty couldn't answer and asks Sherlock to solve it himself. Help Sherlock in doing so.
Input
First line contains two integers n and m (3 ≤ n ≤ 100000, 0 ≤ m ≤ n - 3), the number of vertices in the polygon and the number of diagonals added.
Each of the next m lines contains two integers a and b (1 ≤ a, b ≤ n), describing a diagonal between vertices a and b. It is guaranteed that the diagonals are correct, i. e. a and b don't coincide and are not neighboring. It is guaranteed that the diagonals do not intersect.
Output
Let the number of regions be k.
Output k space-separated integers, each between 1 and 20, representing the colors of the regions in the order of increasing importance.
If there are multiple answers, print any of them. It can be shown that at least one answer exists.
Examples
Input
4 1
1 3
Output
1 2
Input
6 3
1 3
1 4
1 5
Output
2 1 2 3
Note
In 2nd input, regions formed in order after sorting will be (1, 2, 3), (1, 3, 4), (1, 4, 5), (1, 5, 6), i.e, region (1, 2, 3) is first region followed by region (1, 3, 4) and so on.
So, we can color regions 1 and 3 with same color, as region number 2 is on the path from 1 to 3 and it has color 1 which is less than color of 1 and 3, i.e., color number 2.
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 20], *p1, *p2;
template <class T>
inline void read(T &n) {
char ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2)
? 0
: *p1++);
T w = 1, x = 0;
while (!isdigit(ch)) {
if (ch == '-') w = -1;
ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2)
? 0
: *p1++);
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2)
? 0
: *p1++);
}
n = x * w;
}
const int maxn = 100005;
int n, m, tot, nxt[maxn << 2];
int last[maxn], Next[maxn << 2], fr[maxn << 2], to[maxn << 2], cnt = 1;
inline void addedge(int x, int y) {
Next[++cnt] = last[x], last[x] = cnt;
fr[cnt] = x, to[cnt] = y;
}
pair<int, int> bot[maxn << 1];
int bel[maxn << 2], num;
vector<int> node[maxn];
void build(int x) {
bel[x] = ++num;
int st = fr[x];
node[num].push_back(st);
for (; to[x] != st; x = nxt[x]) {
node[num].push_back(to[x]);
bel[nxt[x]] = num;
}
sort(node[num].begin(), node[num].end(), greater<int>());
}
int id[maxn], rk[maxn];
bool cmp(int x, int y) {
for (int i = 0; i < (int)node[x].size(); i++)
if (node[x][i] != node[y][i]) return node[x][i] < node[y][i];
}
void Sort() {
for (int i = 1; i <= num; i++) id[i] = i;
sort(id + 1, id + num + 1, cmp);
for (int i = 1; i <= num; i++) rk[id[i]] = i;
}
int size[maxn], maxp[maxn], col[maxn], rt, sz;
void getrt(int x, int fa) {
size[x] = 1, maxp[x] = 0;
for (int i = last[x]; i; i = Next[i]) {
int v = to[i];
if (!col[v] && v != fa) {
getrt(v, x);
size[x] += size[v];
maxp[x] = max(maxp[x], size[v]);
}
}
maxp[x] = max(maxp[x], sz - size[x]);
if (maxp[x] < maxp[rt]) rt = x;
}
void solve(int x, int dep) {
col[x] = dep;
getrt(x, 0);
for (int i = last[x]; i; i = Next[i]) {
int v = to[i];
if (!col[v]) {
rt = 0, sz = size[v];
getrt(v, x);
solve(rt, dep + 1);
}
}
}
int main() {
read(n), read(m);
for (int i = 1; i <= n; i++) addedge(i, i % n + 1), addedge(i % n + 1, i);
for (int i = 1, x, y; i <= m; i++) {
read(x), read(y);
addedge(x, y), addedge(y, x);
}
for (int x = 1; x <= n; x++) {
tot = 0;
for (int i = last[x]; i; i = Next[i]) bot[++tot] = make_pair(to[i], i);
sort(bot + 1, bot + tot + 1);
for (int i = 1; i <= tot; i++) {
int j = bot[i % tot + 1].second;
nxt[bot[i].second ^ 1] = j;
}
}
for (int i = 2; i <= cnt; i++)
if (!bel[i]) {
if (to[i] == fr[i] % n + 1) continue;
build(i);
}
Sort();
int tmp = cnt;
memset(last, 0, sizeof(last)), cnt = 0;
for (int i = 2; i <= tmp; i += 2)
if (bel[i] && bel[i ^ 1]) {
addedge(rk[bel[i]], rk[bel[i ^ 1]]);
addedge(rk[bel[i ^ 1]], rk[bel[i]]);
}
maxp[0] = n + 1, sz = num;
getrt(1, 0);
solve(rt, 1);
for (int i = 1; i <= num; i++) printf("%d ", col[i]);
return 0;
}
|
You found a mysterious function f. The function takes two strings s1 and s2. These strings must consist only of lowercase English letters, and must be the same length.
The output of the function f is another string of the same length. The i-th character of the output is equal to the minimum of the i-th character of s1 and the i-th character of s2.
For example, f("ab", "ba") = "aa", and f("nzwzl", "zizez") = "niwel".
You found two strings x and y of the same length and consisting of only lowercase English letters. Find any string z such that f(x, z) = y, or print -1 if no such string z exists.
Input
The first line of input contains the string x.
The second line of input contains the string y.
Both x and y consist only of lowercase English letters, x and y have same length and this length is between 1 and 100.
Output
If there is no string z such that f(x, z) = y, print -1.
Otherwise, print a string z such that f(x, z) = y. If there are multiple possible answers, print any of them. The string z should be the same length as x and y and consist only of lowercase English letters.
Examples
Input
ab
aa
Output
ba
Input
nzwzl
niwel
Output
xiyez
Input
ab
ba
Output
-1
Note
The first case is from the statement.
Another solution for the second case is "zizez"
There is no solution for the third case. That is, there is no z such that f("ab", z) = "ba".
|
x = input()
y = input()
z = ''
for i in range(len(x)):
if x[i] < y[i]:
print("-1")
exit(0)
else:
z = z + y[i]
print(z)
|
Okabe likes to be able to walk through his city on a path lit by street lamps. That way, he doesn't get beaten up by schoolchildren.
Okabe's city is represented by a 2D grid of cells. Rows are numbered from 1 to n from top to bottom, and columns are numbered 1 to m from left to right. Exactly k cells in the city are lit by a street lamp. It's guaranteed that the top-left cell is lit.
Okabe starts his walk from the top-left cell, and wants to reach the bottom-right cell. Of course, Okabe will only walk on lit cells, and he can only move to adjacent cells in the up, down, left, and right directions. However, Okabe can also temporarily light all the cells in any single row or column at a time if he pays 1 coin, allowing him to walk through some cells not lit initially.
Note that Okabe can only light a single row or column at a time, and has to pay a coin every time he lights a new row or column. To change the row or column that is temporarily lit, he must stand at a cell that is lit initially. Also, once he removes his temporary light from a row or column, all cells in that row/column not initially lit are now not lit.
Help Okabe find the minimum number of coins he needs to pay to complete his walk!
Input
The first line of input contains three space-separated integers n, m, and k (2 ≤ n, m, k ≤ 104).
Each of the next k lines contains two space-separated integers ri and ci (1 ≤ ri ≤ n, 1 ≤ ci ≤ m) — the row and the column of the i-th lit cell.
It is guaranteed that all k lit cells are distinct. It is guaranteed that the top-left cell is lit.
Output
Print the minimum number of coins Okabe needs to pay to complete his walk, or -1 if it's not possible.
Examples
Input
4 4 5
1 1
2 1
2 3
3 3
4 3
Output
2
Input
5 5 4
1 1
2 1
3 1
3 2
Output
-1
Input
2 2 4
1 1
1 2
2 1
2 2
Output
0
Input
5 5 4
1 1
2 2
3 3
4 4
Output
3
Note
In the first sample test, Okabe can take the path <image>, paying only when moving to (2, 3) and (4, 4).
In the fourth sample, Okabe can take the path <image> <image>, paying when moving to (1, 2), (3, 4), and (5, 4).
|
#include <bits/stdc++.h>
using namespace std;
int inf;
int x[100100], y[100100], n, m, k, st, en;
int abss(int x) { return x > 0 ? x : -x; }
int dist(int a, int b) {
if (a == b) return 2;
if (x[a] == x[b] || y[a] == y[b])
return max(abss(x[a] - x[b]), abss(y[a] - y[b])) == 1 ? 0 : 1;
return min(abss(x[a] - x[b]), abss(y[a] - y[b])) < 3 ? 1 : 2;
}
queue<int> q;
int in[100100], d[100100];
int spfa() {
while (!q.empty()) q.pop();
q.push(st);
memset(in, 0, sizeof(in));
memset(d, 38, sizeof(d));
inf = d[0];
d[st] = 0;
int x, y, dis;
while (!q.empty()) {
x = q.front();
q.pop();
if (x == en) continue;
in[x] = 0;
for (int i = 1; i <= k; i++)
if ((dis = dist(x, i)) < 2) {
if (d[i] > d[x] + dis) {
d[i] = d[x] + dis;
if (!in[i]) {
in[i] = 1;
q.push(i);
}
}
}
}
if (d[en] == inf) return -1;
return d[en];
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
scanf("%d%d", &x[i], &y[i]);
if (x[i] == 1 && y[i] == 1) st = i;
if (x[i] == n && y[i] == m) en = i;
}
if (en == 0) {
k++;
en = k;
x[k] = n + 1;
y[k] = m + 1;
}
printf("%d\n", spfa());
return 0;
}
|
A new dog show on TV is starting next week. On the show dogs are required to demonstrate bottomless stomach, strategic thinking and self-preservation instinct. You and your dog are invited to compete with other participants and naturally you want to win!
On the show a dog needs to eat as many bowls of dog food as possible (bottomless stomach helps here). Dogs compete separately of each other and the rules are as follows:
At the start of the show the dog and the bowls are located on a line. The dog starts at position x = 0 and n bowls are located at positions x = 1, x = 2, ..., x = n. The bowls are numbered from 1 to n from left to right. After the show starts the dog immediately begins to run to the right to the first bowl.
The food inside bowls is not ready for eating at the start because it is too hot (dog's self-preservation instinct prevents eating). More formally, the dog can eat from the i-th bowl after ti seconds from the start of the show or later.
It takes dog 1 second to move from the position x to the position x + 1. The dog is not allowed to move to the left, the dog runs only to the right with the constant speed 1 distance unit per second. When the dog reaches a bowl (say, the bowl i), the following cases are possible:
* the food had cooled down (i.e. it passed at least ti seconds from the show start): the dog immediately eats the food and runs to the right without any stop,
* the food is hot (i.e. it passed less than ti seconds from the show start): the dog has two options: to wait for the i-th bowl, eat the food and continue to run at the moment ti or to skip the i-th bowl and continue to run to the right without any stop.
After T seconds from the start the show ends. If the dog reaches a bowl of food at moment T the dog can not eat it. The show stops before T seconds if the dog had run to the right of the last bowl.
You need to help your dog create a strategy with which the maximum possible number of bowls of food will be eaten in T seconds.
Input
Two integer numbers are given in the first line - n and T (1 ≤ n ≤ 200 000, 1 ≤ T ≤ 2·109) — the number of bowls of food and the time when the dog is stopped.
On the next line numbers t1, t2, ..., tn (1 ≤ ti ≤ 109) are given, where ti is the moment of time when the i-th bowl of food is ready for eating.
Output
Output a single integer — the maximum number of bowls of food the dog will be able to eat in T seconds.
Examples
Input
3 5
1 5 3
Output
2
Input
1 2
1
Output
1
Input
1 1
1
Output
0
Note
In the first example the dog should skip the second bowl to eat from the two bowls (the first and the third).
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 200;
const long long inf = 2e18, mod = 1e9 + 7;
struct node {
int key, prior, cnt, sum;
node* l;
node* r;
node(int KEY = 0, int PRIOR = 0, int CNT = 1) {
key = KEY;
sum = cnt = CNT;
prior = PRIOR;
l = r = NULL;
}
};
typedef node* pnode;
int getSum(pnode t) { return (t ? t->sum : 0); }
inline void update(pnode& t) {
if (t) t->sum = getSum(t->l) + getSum(t->r) + t->cnt;
}
void split(pnode t, int key, pnode& l, pnode& r) {
if (!t)
l = r = NULL;
else if (key < t->key)
split(t->l, key, l, t->l), r = t;
else
split(t->r, key, t->r, r), l = t;
update(t);
}
void addVal(pnode& t, int key) {
if (t->key == key)
t->cnt++;
else if (key < t->key)
addVal(t->l, key);
else
addVal(t->r, key);
update(t);
}
void insert(pnode& t, pnode it) {
if (!t)
t = it;
else if (it->prior > t->prior) {
split(t, it->key, it->l, it->r), t = it;
} else
insert((it->key < t->key ? t->l : t->r), it);
update(t);
}
void merge(pnode& t, pnode& l, pnode& r) {
if (!l || !r)
t = (l ? l : r);
else if (l->prior > r->prior)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
update(t);
}
void erase(pnode& t, int key) {
if (!t) return;
if (t->key == key)
merge(t, t->l, t->r);
else
erase((key < t->key ? t->l : t->r), key);
update(t);
}
int query(pnode t, int key) {
if (!t) return 0;
if (key < t->key)
return query(t->l, key);
else if (key == t->key)
return getSum(t->l);
else
return getSum(t->l) + t->cnt + query(t->r, key);
}
void print(pnode t) {
if (!t) return;
cerr << "P " << t->key << ' ' << t->sum << endl;
print(t->l);
print(t->r);
}
node treapNodes[maxn];
pnode TREAP;
set<int> st;
int n, T, cool[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
srand(time(NULL));
for (int i = 0; i < maxn; i++) treapNodes[i].prior = rand() % mod;
cin >> n >> T;
for (int i = 0; i < n; i++) cin >> cool[i];
for (int i = 0; i < n; i++) cool[i] = max(0, cool[i] - i - 1);
int ind = 0, ans = 0;
for (int i = 0; i < n; i++) {
treapNodes[ind].key = cool[i];
if (st.find(cool[i]) == st.end()) {
insert(TREAP, treapNodes + ind);
st.insert(cool[i]);
} else {
addVal(TREAP, cool[i]);
}
ind++;
ans = max(ans, query(TREAP, T - i - 1));
}
cout << ans << endl;
}
|
You are given an array of n integers a1... an. The cost of a subsegment is the number of unordered pairs of distinct indices within the subsegment that contain equal elements. Split the given array into k non-intersecting non-empty subsegments so that the sum of their costs is minimum possible. Each element should be present in exactly one subsegment.
Input
The first line contains two integers n and k (2 ≤ n ≤ 105, 2 ≤ k ≤ min (n, 20)) — the length of the array and the number of segments you need to split the array into.
The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n) — the elements of the array.
Output
Print single integer: the minimum possible total cost of resulting subsegments.
Examples
Input
7 3
1 1 3 3 3 2 1
Output
1
Input
10 2
1 2 1 2 1 2 1 2 1 2
Output
8
Input
13 3
1 2 2 2 1 2 1 1 1 2 2 1 1
Output
9
Note
In the first example it's optimal to split the sequence into the following three subsegments: [1], [1, 3], [3, 3, 2, 1]. The costs are 0, 0 and 1, thus the answer is 1.
In the second example it's optimal to split the sequence in two equal halves. The cost for each half is 4.
In the third example it's optimal to split the sequence in the following way: [1, 2, 2, 2, 1], [2, 1, 1, 1, 2], [2, 1, 1]. The costs are 4, 4, 1.
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
const int N = 1e5 + 10;
int buc[N], L, R, a[N];
long long ans;
void update(int c, int d) { ans += d * buc[c] * (long long)(buc[c] - 1) / 2; }
long long cal(int l, int r) {
while (L < l) update(a[L], -1), buc[a[L]]--, update(a[L], 1), L++;
while (L > l) L--, update(a[L], -1), buc[a[L]]++, update(a[L], 1);
while (R < r) R++, update(a[R], -1), buc[a[R]]++, update(a[R], 1);
while (R > r) update(a[R], -1), buc[a[R]]--, update(a[R], 1), R--;
return ans;
}
long long dp[22][N];
int cur;
void solve(int lb, int rb, int l, int r) {
if (lb > rb || l > r) return;
int mid = l + r >> 1;
int d = 0;
long long res = 1e18;
for (int i = lb; i <= rb; ++i) {
long long tmp = cal(i + 1, mid);
if (res > dp[cur - 1][i] + tmp) res = dp[cur - 1][i] + tmp, d = i;
}
dp[cur][mid] = res;
solve(lb, d, l, mid - 1), solve(d, rb, mid + 1, r);
}
int main() {
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
int n, m;
read(n), read(m);
for (int i = 1; i <= n; ++i) read(a[i]);
buc[a[1]]++, L = R = 1;
for (cur = 1; cur <= m; ++cur) solve(0, n - 1, 1, n);
printf("%lld", dp[m][n]);
return 0;
}
|
In a dream Marco met an elderly man with a pair of black glasses. The man told him the key to immortality and then disappeared with the wind of time.
When he woke up, he only remembered that the key was a sequence of positive integers of some length n, but forgot the exact sequence. Let the elements of the sequence be a1, a2, ..., an. He remembered that he calculated gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n and put it into a set S. gcd here means the [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor).
Note that even if a number is put into the set S twice or more, it only appears once in the set.
Now Marco gives you the set S and asks you to help him figure out the initial sequence. If there are many solutions, print any of them. It is also possible that there are no sequences that produce the set S, in this case print -1.
Input
The first line contains a single integer m (1 ≤ m ≤ 1000) — the size of the set S.
The second line contains m integers s1, s2, ..., sm (1 ≤ si ≤ 106) — the elements of the set S. It's guaranteed that the elements of the set are given in strictly increasing order, that means s1 < s2 < ... < sm.
Output
If there is no solution, print a single line containing -1.
Otherwise, in the first line print a single integer n denoting the length of the sequence, n should not exceed 4000.
In the second line print n integers a1, a2, ..., an (1 ≤ ai ≤ 106) — the sequence.
We can show that if a solution exists, then there is a solution with n not exceeding 4000 and ai not exceeding 106.
If there are multiple solutions, print any of them.
Examples
Input
4
2 4 6 12
Output
3
4 6 12
Input
2
2 3
Output
-1
Note
In the first example 2 = gcd(4, 6), the other elements from the set appear in the sequence, and we can show that there are no values different from 2, 4, 6 and 12 among gcd(ai, ai + 1, ..., aj) for every 1 ≤ i ≤ j ≤ n.
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9, PI = acos(-1.);
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
const int N = 1e3 + 5, M = 1e6 + 5;
int n, a[N];
vector<int> v;
int main() {
scanf("%d", &n);
int ok = 1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
ok = ok && (a[i] % a[0] == 0);
}
if (ok) {
printf("%d\n", 2 * n + 1);
for (int i = 0; i < n; i++) printf("%d %d ", a[0], a[i]);
printf("%d\n", a[0]);
} else
printf("-1\n");
return 0;
}
|
You are given a tree T consisting of n vertices. A number is written on each vertex; the number written on vertex i is ai. Let's denote the function I(x, y) as the difference between maximum and minimum value of ai on a simple path connecting vertices x and y.
Your task is to calculate <image>.
Input
The first line contains one integer number n (1 ≤ n ≤ 106) — the number of vertices in the tree.
The second line contains n integer numbers a1, a2, ..., an (1 ≤ ai ≤ 106) — the numbers written on the vertices.
Then n - 1 lines follow. Each line contains two integers x and y denoting an edge connecting vertex x and vertex y (1 ≤ x, y ≤ n, x ≠ y). It is guaranteed that these edges denote a tree.
Output
Print one number equal to <image>.
Example
Input
4
2 2 3 1
1 2
1 3
1 4
Output
6
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)1e6 + 5;
int n;
pair<int, int> a[MAXN];
vector<int> e[MAXN];
bool mark[MAXN];
ll solmax = 0, solmin = 0;
int sz[MAXN], p[MAXN];
int root(int u) {
while (p[u] != u) u = p[p[u]];
return u;
}
int sizee(int u) { return sz[root(u)]; }
void join(int u, int v) {
int ur = root(u);
int vr = root(v);
if (sz[ur] < sz[vr]) {
p[ur] = vr;
sz[vr] += sz[ur];
} else {
p[vr] = ur;
sz[ur] += sz[vr];
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a + 1, a + n + 1);
int u, v;
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
memset(mark, 0, sizeof(mark) * sizeof(bool));
for (int i = 1; i <= n; ++i) {
int v = a[i].second;
p[v] = v;
sz[v] = 1;
ll s2 = 0, s = 0;
for (int u : e[v]) {
if (mark[u]) {
int x = sizee(u);
s += x;
s2 += 1LL * x * x;
join(v, u);
}
}
solmax += ((s * s - s2) / 2 + s + 1) * a[i].first;
mark[v] = 1;
}
memset(mark, 0, sizeof(mark) * sizeof(bool));
for (int i = n; i >= 1; --i) {
int v = a[i].second;
p[v] = v;
sz[v] = 1;
ll s2 = 0, s = 0;
for (int u : e[v]) {
if (mark[u]) {
int x = sizee(u);
s += x;
s2 += 1LL * x * x;
join(v, u);
}
}
solmin += ((s * s - s2) / 2 + s + 1) * a[i].first;
mark[v] = 1;
}
cout << solmax - solmin;
return 0;
}
|
You are given an undirected connected graph with weighted edges. The length of some path between two vertices is the bitwise xor of weights of all edges belonging to this path (if some edge is traversed more than once, then it is included in bitwise xor the same number of times).
There are three types of queries you have to process:
* 1 x y d — add an edge connecting vertex x to vertex y with weight d. It is guaranteed that there is no edge connecting x to y before this query;
* 2 x y — remove an edge connecting vertex x to vertex y. It is guaranteed that there was such edge in the graph, and the graph stays connected after this query;
* 3 x y — calculate the length of the shortest path (possibly non-simple) from vertex x to vertex y.
Print the answers for all queries of type 3.
Input
The first line contains two numbers n and m (1 ≤ n, m ≤ 200000) — the number of vertices and the number of edges in the graph, respectively.
Then m lines follow denoting the edges of the graph. Each line contains three integers x, y and d (1 ≤ x < y ≤ n, 0 ≤ d ≤ 230 - 1). Each pair (x, y) is listed at most once. The initial graph is connected.
Then one line follows, containing an integer q (1 ≤ q ≤ 200000) — the number of queries you have to process.
Then q lines follow, denoting queries in the following form:
* 1 x y d (1 ≤ x < y ≤ n, 0 ≤ d ≤ 230 - 1) — add an edge connecting vertex x to vertex y with weight d. It is guaranteed that there is no edge connecting x to y before this query;
* 2 x y (1 ≤ x < y ≤ n) — remove an edge connecting vertex x to vertex y. It is guaranteed that there was such edge in the graph, and the graph stays connected after this query;
* 3 x y (1 ≤ x < y ≤ n) — calculate the length of the shortest path (possibly non-simple) from vertex x to vertex y.
It is guaranteed that at least one query has type 3.
Output
Print the answers for all queries of type 3 in the order they appear in input.
Example
Input
5 5
1 2 3
2 3 4
3 4 5
4 5 6
1 5 1
5
3 1 5
1 1 3 1
3 1 5
2 1 5
3 1 5
Output
1
1
2
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
const int N = 4e5 + 5;
struct ele {
int u, v, val;
ele(int a = 0, int b = 0, int c = 0) : u(a), v(b), val(c) {}
};
bool operator<(const ele a, const ele b) {
if (a.u != b.u) return a.u < b.u;
return a.v < b.v;
}
map<ele, pair<int, int> > wxw;
map<ele, pair<int, int> >::iterator it;
vector<ele> t[N << 2], Q[N];
int fa[N], w[N], siz[N], ans[N], st[N];
int n, m, q, tot, cntq, top;
int find(int x) {
while (fa[x] != x) x = fa[x];
return x;
}
int dis(int x) {
int ans = 0;
while (fa[x] != x) {
ans ^= w[x];
x = fa[x];
}
return ans;
}
void change(int u, int l, int r, int L, int R, ele x) {
if (l <= L && R <= r) {
t[u].push_back(x);
return;
}
int mid = (L + R) >> 1;
if (mid >= l) change(u << 1, l, r, L, mid, x);
if (mid + 1 <= r) change(u << 1 | 1, l, r, mid + 1, R, x);
}
struct lbase_t {
int a[30];
void insert(int x) {
for (register int i = 29; i >= 0; i--) {
if ((x >> i) & 1) {
if (!a[i]) {
a[i] = x;
break;
}
x ^= a[i];
}
}
}
int query(int x) {
for (register int i = 29; i >= 0; i--) {
if ((x ^ a[i]) < x) x ^= a[i];
}
return x;
}
} tb[30];
void query(int u, int l, int r, int dep) {
int now = top;
tb[dep] = tb[dep - 1];
for (register int i = 0; i < (int)t[u].size(); i++) {
int x = find(t[u][i].u), y = find(t[u][i].v);
if (x == y) {
tb[dep].insert(dis(t[u][i].u) ^ dis(t[u][i].v) ^ t[u][i].val);
continue;
}
int val = dis(t[u][i].u) ^ dis(t[u][i].v) ^ t[u][i].val;
if (siz[x] >= siz[y]) swap(x, y);
fa[x] = y;
siz[y] += siz[x];
w[x] = val;
st[++top] = x;
}
if (l != r) {
int mid = (l + r) >> 1;
query(u << 1, l, mid, dep + 1);
query(u << 1 | 1, mid + 1, r, dep + 1);
}
if (l == r) {
for (register int i = 0; i < (int)Q[l].size(); i++) {
ans[Q[l][i].val] = tb[dep].query(dis(Q[l][i].u) ^ dis(Q[l][i].v));
}
}
while (top != now) {
int x = st[top--], y = fa[x];
siz[y] -= siz[x];
fa[x] = x;
w[x] = 0;
}
}
int main() {
read(n);
read(m);
for (register int i = 1; i <= n; i++) fa[i] = i, siz[i] = 1;
for (register int i = 1; i <= m; i++) {
int u, v, val;
read(u);
read(v);
read(val);
wxw[ele(u, v)] = make_pair(val, ++tot);
}
read(q);
for (register int i = 1; i <= q; i++) {
int opt;
read(opt);
if (opt == 1) {
int u, v, val;
read(u);
read(v);
read(val);
wxw[ele(u, v)] = make_pair(val, ++tot);
}
if (opt == 2) {
int u, v;
read(u);
read(v);
pair<int, int> tmp = wxw[ele(u, v)];
wxw.erase(ele(u, v));
change(1, tmp.second, tot, 1, m + q, ele(u, v, tmp.first));
++tot;
}
if (opt == 3) {
int u, v;
read(u);
read(v);
Q[tot].push_back(ele(u, v, ++cntq));
}
}
for (it = wxw.begin(); it != wxw.end(); ++it)
change(1, (it->second).second, m + q, 1, m + q,
ele((it->first).u, (it->first).v, (it->second).first));
query(1, 1, m + q, 1);
for (register int i = 1; i <= cntq; i++) print(ans[i], '\n');
return 0;
}
|
There are n incoming messages for Vasya. The i-th message is going to be received after ti minutes. Each message has a cost, which equals to A initially. After being received, the cost of a message decreases by B each minute (it can become negative). Vasya can read any message after receiving it at any moment of time. After reading the message, Vasya's bank account receives the current cost of this message. Initially, Vasya's bank account is at 0.
Also, each minute Vasya's bank account receives C·k, where k is the amount of received but unread messages.
Vasya's messages are very important to him, and because of that he wants to have all messages read after T minutes.
Determine the maximum amount of money Vasya's bank account can hold after T minutes.
Input
The first line contains five integers n, A, B, C and T (1 ≤ n, A, B, C, T ≤ 1000).
The second string contains n integers ti (1 ≤ ti ≤ T).
Output
Output one integer — the answer to the problem.
Examples
Input
4 5 5 3 5
1 5 5 4
Output
20
Input
5 3 1 1 3
2 2 2 1 1
Output
15
Input
5 5 3 4 5
1 2 3 4 5
Output
35
Note
In the first sample the messages must be read immediately after receiving, Vasya receives A points for each message, n·A = 20 in total.
In the second sample the messages can be read at any integer moment.
In the third sample messages must be read at the moment T. This way Vasya has 1, 2, 3, 4 and 0 unread messages at the corresponding minutes, he gets 40 points for them. When reading messages, he receives (5 - 4·3) + (5 - 3·3) + (5 - 2·3) + (5 - 1·3) + 5 = - 5 points. This is 35 in total.
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, A, B, C, T;
cin >> n >> A >> B >> C >> T;
long long int sum = 0;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
if (C >= B)
sum += 0LL + (C - B) * (T - t) + A;
else
sum += A + 0LL;
}
cout << sum << endl;
return 0;
}
|
After passing a test, Vasya got himself a box of n candies. He decided to eat an equal amount of candies each morning until there are no more candies. However, Petya also noticed the box and decided to get some candies for himself.
This means the process of eating candies is the following: in the beginning Vasya chooses a single integer k, same for all days. After that, in the morning he eats k candies from the box (if there are less than k candies in the box, he eats them all), then in the evening Petya eats 10\% of the candies remaining in the box. If there are still candies left in the box, the process repeats — next day Vasya eats k candies again, and Petya — 10\% of the candies left in a box, and so on.
If the amount of candies in the box is not divisible by 10, Petya rounds the amount he takes from the box down. For example, if there were 97 candies in the box, Petya would eat only 9 of them. In particular, if there are less than 10 candies in a box, Petya won't eat any at all.
Your task is to find out the minimal amount of k that can be chosen by Vasya so that he would eat at least half of the n candies he initially got. Note that the number k must be integer.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^{18}) — the initial amount of candies in the box.
Output
Output a single integer — the minimal amount of k that would allow Vasya to eat at least half of candies he got.
Example
Input
68
Output
3
Note
In the sample, the amount of candies, with k=3, would change in the following way (Vasya eats first):
68 → 65 → 59 → 56 → 51 → 48 → 44 → 41 \\\ → 37 → 34 → 31 → 28 → 26 → 23 → 21 → 18 → 17 → 14 \\\ → 13 → 10 → 9 → 6 → 6 → 3 → 3 → 0.
In total, Vasya would eat 39 candies, while Petya — 29.
|
def ok(n, k):
a, n0 = 0, n
while n > 0:
if n <= k:
n, a = 0, a+n
break
n, a = n-k, a+k
n -= n / 10
#print k, a
return 2*a >= n0
n = int(raw_input())
lo, hi = 1, n
while lo <= hi:
mid = (lo+hi)>>1
if ok(n, mid): hi = mid-1
else: lo = mid+1
hi = max(1,hi)
if ok(n,hi):
print hi
else:
print hi+1
|
Archith was a making noise in digital logic class.Sir was very frustrated by the behaviour of Archith. Sir asked archith to meet him in staff room. As archith reached staff room sir gave a smile and asked to complete this assignment in one day if not he will be suspended. Archith has low attendence so he has to complete the assignment in one day.Assignment consists of checking a parity of numbers and there were huge no of numbers .So he asked your help to sove this problem for him.
INPUT :
first line consists of T test cases.
Next T lines consists of decimal numbers N.
OUTPUT :
It should print the given number as "even" if the number has even number of 1's in binary form and "odd" if the number has odd number of 1's in binary form.
0<T<100
0<N<10^9
SAMPLE INPUT
2
12
14
SAMPLE OUTPUT
even
odd
|
testcases = raw_input()
for i in range(int(testcases)):
decimal_number = raw_input()
if str(bin(int(decimal_number))[2 :]).count('1') % 2 == 0:
print "even"
else:
print "odd"
|
Chang loves solving mathematical puzzles. One day he was solving a puzzle. According to the problem statement of the puzzle: "there are N integers. you are asked to delete some numbers such that the series obtained after deletion follows the condition.
(condition/equation): a - 3b ≤ 0 where a is the maximum and b is the minimum of the series obtained after deletion is done. This condition/equation must be followed by the series of numbers obtained by deleting some numbers from original series of numbers".
The question asks to tell the mininium number of integers to be deleted so that the above condition is followed by the remaining numbers obtained after deletion. Help chang in solving this mathematical brainbuster.
INPUT
The first line contain number of integers "N".The second line contains those N integers.
OUTPUT
output a single integer ie.the minimum number of integers needed to be removed to follow the condition.
Constraint
1 ≤ N ≤ 10^4
1 ≤ input number ≤ 10^4
SAMPLE INPUT
3
1 2 4
SAMPLE OUTPUT
1
Explanation
here if we remove 4 from the series.Then we will be left with 1 and 2
which satisfies the condition a-3b ≤ 0
so the answer will be 1.
|
# your code goes here
N=input()
a=[]
hash=[0]*10005
a=map(int,raw_input().split())
for i in a:
hash[i]+=1
sum=0
for i in range(0,10005):
sum+=hash[i]
hash[i]=sum
a.sort()
ans=1000000
for i in range(1,a[N-1]):
if(3*i<10004):
ans=min(ans,N-(hash[3*i]-hash[i-1]))
print ans
|
Rakesh is very good in divisibility. He can easily tell the number is divisible by the given number or not. To make him work harder his teacher changed the question slightly. He will give the number and the other number with which the first number is divisible or not to make it complicated he will mention the range in between he need to tell how many continuous sub numbers are divisible by it or not.
Example:
consider a number 123456
number is 3,
range is 1 to 3. Among all combinations between these ranges there are only 3 sub numbers i.e., 3,123,12 are divisilble. So print 3 as output.
INPUT:
First line consists of T testcases
Evert test case has a number followed by the number in next line and range in the following next line.
OUTPUT:
Print the number of sub numbers divisible by the given number.
Range:
0<T<100
0<number<10^50
0<div<10000
SAMPLE INPUT
2
1254756
4
1 5
54789623
6
2 6
SAMPLE OUTPUT
2
4
|
for _ in range(int(raw_input())):
li=[]
m=raw_input()
div=int(raw_input())
x,y=map(int,raw_input().split())
x-=1
y-=1
m=m[x:y+1]
#print(m)
for i in range(y-x+1):
for j in range(i+1,y-x+2):
if int(m[i:j])%div==0:
li.append(m[i:j])
print(len(li))
|
HackerEarth has sponsored a lot of goodies for the 'Google Week' to be held at Sir MVIT. The goodies are in the form of boxes. Each box has a surprise value associated with it.
To carry the boxes from his hostel to the venue, Karan puts the box with the smaller surprise value inside the box with larger surprise value. A box can only contain a single box inside it. Basically, if surprise_value[i]<surprise_value[j], then j can accommodate i inside it.
Input
The first line contains the number of test cases T. Every test case contains a number N, denoting the number of total goodie boxes. This is followed by N lines, containing the surprise value of each box, X.
Output
You've to output the minimum number of boxes, optimally putting one inside each other.
Constraints
1 ≤ T ≤ 10
1 ≤ N ≤ 100000
1 ≤ X ≤ 10000
SAMPLE INPUT
3
3
1
2
3
4
2
2
2
2
3
11
111
1111
SAMPLE OUTPUT
1
4
1
Explanation
Explanation
Test Case # 1:
There are three boxes of value 1 , 2 and 3
Box of value 1 can fit inside box of value 2 and now box of value 2 which contains box of value 1 can fit inside box of value 3. So finally there will be only one box.
Test Case # 2:
There are four boxes of same value 2 so we can't put boxes inside of any other box of same value. So the answer will be 4.
Test Case # 3:
There are three boxes of value 11,111,1111 . Box of value 11 can fit inside box of value 111 and box of value 111 which contains box of value 11 can fit inside box of value 1111 . At final there will be only one box so answer is 1.
|
'''
Easy Goodies
'''
def fun_wid_code():
tc=int(raw_input())
while(tc):
num=[0]*10001
n=int(raw_input())
while(n):
k=int(raw_input())
num[k]+=1
n-=1
num.sort()
num.reverse()
print num[0]
tc-=1
fun_wid_code()
|
Little Fajlu and Laal Baadshah are extremely good, and passionate Age of Empires 2 players. They're crazy about the game, and the passion they display for the game, if displayed for their semester exams - will make them top the university, even. But well, that's them.
Laal Baadshah relies on rushing through the game, so he tries to create as many weird units as quick as possible, without realizing how much power and strength his total army is giving him. While, Little Fajlu is an extremely smart player - he plans his games in a very smart, and strategic manner... which makes it very difficult to defeat him. Really. Not kidding.
We want the problem solvers to learn Fajlu's strategy, too. So, here it goes.
The top three units he uses are: Samurai, Paladins, and Champions.
The cost of a Samurai is: 100 food, 0 gold.
The cost of a Paladin is: 125 food, 50 gold.
The cost of a Champion is: 50 food, 100 gold.
What Fajlu does is given the state of his current economy, and how much will each unit increase his total advantage over his opponent, he manages to get the maximum army strength he can manage to get.
What you need to do is to calculate this amount quickly, faster than Fajlu and let Laal Baadshah know how much strength will he need to overcome Fajlu?
Input format:
The first line contains a number, T, denoting the number of test cases. The next line contains SIX integers.
1. The amount of food F Fajlu has, where 1 ≤ F ≤ 40000
2. The amount of gold G Fajlu has, where 1 ≤ G ≤ 40000
3. Power of a Samurai S, where 1 ≤ S ≤ 1000
4. Power of a Paladin P , where 1 ≤ P ≤ 1000
5. Power of a Champion C, where 1 ≤ C ≤ 1000
6. Total power Power Laal Baadshah already has, where 1 ≤ Power ≤ 3000
1 ≤ T ≤ 100
Output format:
You've to print how much more power would Laal Baadshah need to defeat Fajlu. If he already has more or equal power to defeat him, print -1.
PS: The image contains violent deaths. Adult supervision required.
SAMPLE INPUT
1
389 130 16 13 18 24
SAMPLE OUTPUT
42
|
def defeat_power(food,gold,s,p,c,tp):
sam = 0
temp = -1
res = -1
while sam*100 <= food:
pal = 0
while ((pal*125 + 100*sam) <= food) and (pal*50<=gold):
food_left = (food-100*sam - 125*pal)
gold_left = (gold-50*pal)
cha = min(food_left/50,gold_left/100)
temp = max(temp,(s*sam+p*pal+c*cha))
pal +=1
sam += 1
if temp>tp:
res = temp-tp
return res
t = int(raw_input())
req_power = []
for tc in range(0,t):
inputs = raw_input()
numbers = inputs.split(' ')
f = int(numbers[0])
g = int(numbers[1])
s = int(numbers[2])
p = int(numbers[3])
c = int(numbers[4])
tp = int(numbers[5])
req_power.append(defeat_power(f,g,s,p,c,tp))
for req in req_power:
print req
|
The evil mastermind, Moriarty, strikes again! He sent Sherlock an image of a wall, with N integers painted on it. Sherlock is asked to solve the puzzle and find the next clue.
Sherlock knows that Moriarty is a deceitful person. All the numbers painted on the wall are not valid. Only the numbers that are Coprime with the integer X are valid, and the rest are a deceit. Help Sherlock find the valid integers from the given array A so that he can track down Moriarty.
Input:
First line contains T. T test cases follow.
First line of each test case contains two space-separated integers N and X.
Second line of each test case contains N space-separated integers, forming the array A.
Output:
Print the valid integers separated by spaces in the order that they appear in the list or "-1" (without the quotes) if there are no valid integers, in a new line for each test case.
Constraints:
1 ≤ T ≤ 10
1 ≤ N ≤ 10^4
2 ≤ Ai, X ≤ 10^7
SAMPLE INPUT
1
5 4
2 5 8 3 13
SAMPLE OUTPUT
5 3 13
|
'''
# Read input from stdin and provide input before running code
name = raw_input('What is your name?\n')
print 'Hi, %s.' % name
'''
def gcd(a,b) :
if b == 0 :
return a
else :
return gcd(b,a%b)
t = int(raw_input())
while t>0 :
t -= 1
n,m = map(int, raw_input().split())
s = []
c=0
ip1=map(int, raw_input().split())
for i in range(0,n):
if(gcd(ip1[i],m) == 1):
s.append(ip1[i])
c+=1
if c==0 :
print '-1'
else :
for i in range(0,c-1):
print (s[i]),
print s[c-1]
|
Let there be a set of size N.
Power set of a set S, denoted by P(S) is the set of all subsets of S, including the empty set and the S itself.
Set A is said to be subset of set B if all elements of A are contained in B. Empty set is always a subset of any non-empty set. Similarly any set is subset of itself.
Set A is said to be equal to set B if all elements of A are present in B and cardinality of both sets is same.
Let us define a new function F.
The three arguments of this function are three elements from P(S).
F\; (A, B, C) = 1 if and only if ( A is a subset of B and B is a subset of C and A is not equal to C)
0, otherwise.
What is the sum of F\; (A,B,C) over all possible different triplets from P(S).
Two triplets A,B,C and D,E,F are said to be different if A\; ! = D or B\; ! = E or C \;! = F.
Input:
First line contains T, denoting the number of testcases. Each test case contains N, the size of set S.
Output:
Print in one line for each testcase, the required answer modulo 10^9 + 7.
Constraints:
1 ≤ T ≤ 100
1 ≤ N ≤ 1000
SAMPLE INPUT
1
2
SAMPLE OUTPUT
12
Explanation
Let us consider our set S to be {a,b}.
So P(S) = { {} , {a}, {b}, {a,b} }.
following triplets have value of F equal to 1.
{} , {}, {a}
{} , {}, {b}
{} , {}, {a,b}
{} , {a}, {a}
{} , {a}, {a,b}
{} , {b}, {b}
{} , {b}, {a,b}
{} , {a,b}, {a,b}
{a}, {a}, {a,b}
{a}, {a,b}, {a,b}
{b} , {b}, {a,b}
{b}, {a,b} , {a,b}
|
t = int(raw_input())
m = 10**9 + 7
for i in range(t):
n = int( raw_input() )
print ( pow( 4 , n , m ) % m - pow( 2 , n , m ) % m ) % m
|
A notice on the notice board read:
“Is there an end to it?
While the number remains greater than one, if 2 divides the number completely, divide the number by 2; while the number remains greater than 1, if the number is not divisible by 2 , multiply the successor of the number by 3 and increment this by three. "
David starts off with a number a wonders if there is an end to it?
Input – a single integer
Output - “Yes” if the program will end, “No” otherwise (quotes for clarity only)
Sample Input:
17
Sample Output:
No
SAMPLE INPUT
17
SAMPLE OUTPUT
No
|
import math
n = input()
if n>=1:
t = math.log(n)/math.log(2)
if n==int(n):
print "Yes"
else:
print "No"
else:
print "No"
|
Given a number N, find the sum of all products x*y such that N/x = y (Integer Division).
Since, the sum can be very large, please output this modulo 1000000007.
Input Format:
The first line of input file contains an integer T, the number of test cases to follow.
Each of the next T lines contain an integer N.
Output Format:
Output T lines containing answer to corresponding test case.
Constraints:
1 ≤ T ≤ 500
1 ≤ N ≤ 10^9
Sample Explanation:
Case #1:
2 / 1 = 2
2 / 2 = 1
Answer = 1 * 2 + 2 * 1 = 4
Case #2:
4 / 1 = 4
4 / 2 = 2
4 / 3 = 1
4 / 4 = 1
Answer = 1 * 4 + 2 * 2 + 3 * 1 + 4 * 1 = 15
SAMPLE INPUT
3
2
4
6
SAMPLE OUTPUT
4
15
33
|
from math import sqrt
t = int(raw_input())
def summ(x):
return x*(x+1)/2
for i in range(t):
n = int(raw_input())
ans = 0
sq = int(sqrt(n))
for i in range(1,sq+1):
r = n//i
l = n//(i+1)
ans += i*r
if(l >= sq):
ans += i*(summ(r)-summ(l))
ans %= 1000000007
print ans
|
Hansa loves dancing and so do her friends. But she has some pretty weird friends. Like this one friend of hers, Jack, jumps forward while dancing. The dance floor is of finite length (L) and there are many people dancing on it. During each song, Jack jumps exactly X steps forward and at the end of the song, he is pushed back Y steps by the other dancers.
Every class has a nerd. This one does too. The nerd doesn’t like dancing but in order to kill time he is watching this jumping Jack. He is counting the number of songs that have been played before Jack reaches the end of the dance floor. Tell us how many songs he counted.
Note: Even if a song doesn’t complete when he reaches the end of the dance floor, but it has started, then it is counted.
Input:
Three space separated integers L, X, Y.
Output:
A single line of output that is the answer to the question.
Constraints:
1 ≤ Y < X ≤ L ≤ 10^9
Problem Setter: Chintan Shah
SAMPLE INPUT
6 5 1
SAMPLE OUTPUT
2
|
n, a, b= map(int, raw_input().split())
# calculate days_nights for n-b distance travelling
# adjust it
print (n-b)/(a-b) + (1 if (n-b)%(a-b) else 0)
|
AtCoder currently hosts three types of contests: ABC, ARC, and AGC. As the number of users has grown, in order to meet the needs of more users, AtCoder has decided to increase the number of contests to 26 types, from AAC to AZC. For convenience, we number these 26 types as type 1 through type 26. AtCoder wants to schedule contests for D days so that user satisfaction is as high as possible. For every day, AtCoder will hold exactly one contest, and each contest will end on that day. The satisfaction is calculated as follows.
* The satisfaction at the beginning of day 1 is 0. Satisfaction can be negative.
* Holding contests increases satisfaction. The amount of increase will vary depending on a variety of factors. Specifically, we know in advance that holding a contest of type i on day d will increase the satisfaction by s_{d,i}.
* If a particular type of contest is not held for a while, the satisfaction decreases. Each contest type i has an integer c_i, and at the end of each day d=1,2,...,D, the satisfaction decreases as follows. Let \mathrm{last}(d,i) be the last day before day d (including d) on which a contest of type i was held. If contests of type i have never been held yet, we define \mathrm{last}(d,i)=0. At the end of day d, the satisfaction decreases by \sum _{i=1}^{26}c_i \times (d-\mathrm{last}(d,i)).
Please schedule contests on behalf of AtCoder. If the satisfaction at the end of day D is S, you will get a score of \max(10^6 + S, 0). There are 50 test cases, and the score of a submission is the total scores for each test case. You can make submissions multiple times, and the highest score among your submissions will be your score.
Constraints
* D = 365
* Each c_i is an integer satisfying 0\leq c_i \leq 100.
* Each s_{d,i} is an integer satisfying 0\leq s_{d,i} \leq 20000.
Input
Input is given from Standard Input in the following format:
D
c_1 c_2 \cdots c_{26}
s_{1,1} s_{1,2} \cdots s_{1,26}
\vdots
s_{D,1} s_{D,2} \cdots s_{D,26}
Output
Let t_d (1\leq t_d \leq 26) be the type of the contest that will be held at day d. Print D integers t_d to Standard Output in the following format:
t_1
t_2
\vdots
t_D
Any output that does not follow the above format may result in ~~0 points~~ WA for that test case.
Input Generation
Each integer c_i and s_{d,i} is generated independently and uniformly at random from the integers in the range described in the problem statement.
Example
Input
5
86 90 69 51 2 96 71 47 88 34 45 46 89 34 31 38 97 84 41 80 14 4 50 83 7 82
19771 12979 18912 10432 10544 12928 13403 3047 10527 9740 8100 92 2856 14730 1396 15905 6534 4650 11469 3628 8433 2994 10899 16396 18355 11424
6674 17707 13855 16407 12232 2886 11908 1705 5000 1537 10440 10711 4917 10770 17272 15364 19277 18094 3929 3705 7169 6159 18683 15410 9092 4570
6878 4239 19925 1799 375 9563 3445 5658 19857 11401 6997 6498 19933 3848 2426 2146 19745 16880 17773 18359 3921 14172 16730 11157 5439 256
8633 15862 15303 10749 18499 7792 10317 5901 9395 11433 3514 3959 5202 19850 19469 9790 5653 784 18500 10552 17975 16615 7852 197 8471 7452
19855 17918 7990 10572 4333 438 9140 9104 12622 4985 12319 4028 19922 12132 16259 17476 2976 547 19195 19830 16285 4806 4471 9457 2864 2192
Output
1
17
13
14
13
|
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigDecimal;
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.ListIterator;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
public class Main {
public static void main(String[] args) throws IOException {
try(final Scanner sc = new Scanner(System.in)){
final int TYPES = 26;
final int D = sc.nextInt();
int[] cs = new int[TYPES];
for(int i = 0; i < TYPES; i++) {
cs[i] = sc.nextInt();
}
int[][] ss = new int[D][TYPES];
for(int i = 0; i < D; i++) {
for(int j = 0; j < TYPES; j++) {
ss[i][j] = sc.nextInt();
}
}
for(int i = 0; i < D; i++) {
System.out.println((i % TYPES) + 1);
}
}
}
public static class Scanner implements Closeable {
private BufferedReader br;
private StringTokenizer tok;
public Scanner(InputStream is) throws IOException {
br = new BufferedReader(new InputStreamReader(is));
}
private void getLine() throws IOException {
while(!hasNext()){
tok = new StringTokenizer(br.readLine());
}
}
private boolean hasNext() {
return tok != null && tok.hasMoreTokens();
}
public String next() throws IOException {
getLine();
return tok.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public int[] nextIntArray(int n) throws IOException {
final int[] ret = new int[n];
for(int i = 0; i < n; i++){
ret[i] = this.nextInt();
}
return ret;
}
public long[] nextLongArray(int n) throws IOException {
final long[] ret = new long[n];
for(int i = 0; i < n; i++){
ret[i] = this.nextLong();
}
return ret;
}
public void close() throws IOException {
br.close();
}
}
}
|
We have a tree with N vertices. The vertices are numbered 1 to N, and the i-th edge connects Vertex a_i and Vertex b_i.
Takahashi loves the number 3. He is seeking a permutation p_1, p_2, \ldots , p_N of integers from 1 to N satisfying the following condition:
* For every pair of vertices (i, j), if the distance between Vertex i and Vertex j is 3, the sum or product of p_i and p_j is a multiple of 3.
Here the distance between Vertex i and Vertex j is the number of edges contained in the shortest path from Vertex i to Vertex j.
Help Takahashi by finding a permutation that satisfies the condition.
Constraints
* 2\leq N\leq 2\times 10^5
* 1\leq a_i, b_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
a_2 b_2
\vdots
a_{N-1} b_{N-1}
Output
If no permutation satisfies the condition, print `-1`.
Otherwise, print a permutation satisfying the condition, with space in between. If there are multiple solutions, you can print any of them.
Example
Input
5
1 2
1 3
3 4
3 5
Output
1 2 5 4 3
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<vector<int>> graph(222222);
vector<int> color(222222,-1);
vector<int> ans(222222,0);
void DFS(int f,int t){
if(f==-1)color[t]=0;
for(auto x:graph[t]){
if(color[x]==-1){
color[x]=(color[t]+1)%2;
DFS(t,x);
}
}
}
int main(){
cin >> N;
for(int i=0;i<N-1;i++){
int a,b;
cin >> a >> b;
a--;
b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
DFS(-1,0);
int c=accumulate(color.begin(),color.begin()+N,0);
if(c<=N/3){
int used3=0;
int used12=0;
for(int i=0;i<N;i++){
if(color[i]==1)ans[i]=3*(++used3);
}
for(int i=0;i<N;i++){
if(ans[i]==0){
if(used3<N/3)ans[i]=3*(++used3);
else{
ans[i]=3*(used12/2)+((used12)%2)+1;
used12++;
}
}
}
}else if((N-c)<=N/3){
int used3=0;
int used12=0;
for(int i=0;i<N;i++){
if(color[i]==0)ans[i]=3*(++used3);
}
for(int i=0;i<N;i++){
if(ans[i]==0){
if(used3<N/3)ans[i]=3*(++used3);
else{
ans[i]=3*(used12/2)+((used12)%2)+1;
used12++;
}
}
}
}else{
int used1=0;
int used2=0;
int used3=0;
for(int i=0;i<N;i++){
if(color[i]==0 && used1<(N+2)/3)ans[i]=1+3*(used1++);
else if(color[i]==1 && used2<(N+1)/3)ans[i]=2+3*(used2++);
else ans[i]=3*(++used3);
}
}
for(int i=0;i<N;i++)printf("%d%c",ans[i],((i<N-1)?(' '):('\n')));
return 0;
}
|
There is a cave consisting of N rooms and M one-directional passages. The rooms are numbered 1 through N.
Takahashi is now in Room 1, and Room N has the exit. The i-th passage connects Room s_i and Room t_i (s_i < t_i) and can only be traversed in the direction from Room s_i to Room t_i. It is known that, for each room except Room N, there is at least one passage going from that room.
Takahashi will escape from the cave. Each time he reaches a room (assume that he has reached Room 1 at the beginning), he will choose a passage uniformly at random from the ones going from that room and take that passage.
Aoki, a friend of Takahashi's, can block one of the passages (or do nothing) before Takahashi leaves Room 1. However, it is not allowed to block a passage so that Takahashi is potentially unable to reach Room N.
Let E be the expected number of passages Takahashi takes before he reaches Room N. Find the value of E when Aoki makes a choice that minimizes E.
Constraints
* 2 \leq N \leq 600
* N-1 \leq M \leq \frac{N(N-1)}{2}
* s_i < t_i
* If i != j, (s_i, t_i) \neq (s_j, t_j). (Added 21:23 JST)
* For every v = 1, 2, ..., N-1, there exists i such that v = s_i.
Input
Input is given from Standard Input in the following format:
N M
s_1 t_1
:
s_M t_M
Output
Print the value of E when Aoki makes a choice that minimizes E. Your output will be judged as correct when the absolute or relative error from the judge's output is at most 10^{-6}.
Examples
Input
4 6
1 4
2 3
1 3
1 2
3 4
2 4
Output
1.5000000000
Input
3 2
1 2
2 3
Output
2.0000000000
Input
10 33
3 7
5 10
8 9
1 10
4 6
2 5
1 7
6 10
1 4
1 3
8 10
1 5
2 6
6 9
5 6
5 8
3 6
4 8
2 7
2 9
6 7
1 2
5 9
6 8
9 10
3 9
7 8
4 5
2 10
5 7
3 5
4 7
4 9
Output
3.0133333333
|
#include<bits/stdc++.h>
using namespace std;
double ans=999999999;
double inf=999999999;
int n,m;
double dp[601];
vector<int>e[601];
void get_dp(int x)
{
memset(dp,0,sizeof(dp));
dp[n]=0;
for(int i=n-1;i>=1;i--)
{
int tot=0;
double mx=0;
for(int j=0;j<e[i].size();j++)
tot++,mx=max(mx,dp[e[i][j]]),dp[i]+=dp[e[i][j]];
if(i==x)
{
if(tot==1)
dp[i]=inf;
else if(tot>=2)
dp[i]-=mx,dp[i]/=tot-1,dp[i]++;
else
dp[i]=inf;
}
else if(tot)
dp[i]/=tot,dp[i]++;
else
dp[i]=inf;
}
ans=min(ans,dp[1]);
}
signed main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
int u,v;
scanf("%d%d",&u,&v);
if(u>v) swap(u,v);
e[u].push_back(v);
}
for(int i=1;i<=n;i++)
get_dp(i);
printf("%lf",ans);
return 0;
}
/*
5 5
1 2
1 3
2 3
3 5
2 5
*/
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.