Three years have passes and nothing changed. It is still raining in London, and Mr. Black has to close all the doors in his home in order to not be flooded. Once, however, Mr. Black became so nervous that he opened one door, then another, then one more and so on until he opened all the doors in his house.
There are exactly two exits from Mr. Black's house, let's name them left and right exits. There are several doors in each of the exits, so each door in Mr. Black's house is located either in the left or in the right exit. You know where each door is located. Initially all the doors are closed. Mr. Black can exit the house if and only if all doors in at least one of the exits is open. You are given a sequence in which Mr. Black opened the doors, please find the smallest index kk such that Mr. Black can exit the house after opening the first kk doors.
We have to note that Mr. Black opened each door at most once, and in the end all doors became open.
The first line contains integer nn (2≤n≤2000002≤n≤200000) — the number of doors.
The next line contains nn integers: the sequence in which Mr. Black opened the doors. The ii-th of these integers is equal to 00 in case the ii-th opened door is located in the left exit, and it is equal to 11 in case it is in the right exit.
It is guaranteed that there is at least one door located in the left exit and there is at least one door located in the right exit.
Print the smallest integer kk such that after Mr. Black opened the first kk doors, he was able to exit the house.
5 0 0 1 0 0
3
4 1 0 0 1
3
In the first example the first two doors are from the left exit, so when Mr. Black opened both of them only, there were two more closed door in the left exit and one closed door in the right exit. So Mr. Black wasn't able to exit at that moment.
When he opened the third door, all doors from the right exit became open, so Mr. Black was able to exit the house.
In the second example when the first two doors were opened, there was open closed door in each of the exit.
With three doors opened Mr. Black was able to use the left exit.
弱智题目 记录最后一个0和1的位置 输出比较小的那个下标就行
#include<bits/stdc++.h> using namespace std; typedef long long ll; const int maxn=2e5+5; const int INF=1e9+5; typedef pair<int,int> pii; int d[maxn],vis[maxn],cnt[maxn],pre[maxn],sum[maxn],val[maxn]; vector<pii> e[maxn]; int n,k; int main() { cin>>n; int a[maxn]; int x=0,y=0,px,py; for(int i=0;i<n;i++) { cin>>a[i]; if(a[i]==0) {x++;px=i;} if(a[i]==1) {y++;py=i;} } if(px>py) cout<<py+1<<endl; else cout<<px+1<<endl; return 0; }
Kurt reaches nirvana when he finds the product of all the digits of some positive integer. Greater value of the product makes the nirvana deeper.
Help Kurt find the maximum possible product of digits among all integers from 11 to nn.
The only input line contains the integer nn (1≤n≤2⋅1091≤n≤2⋅109).
Print the maximum product of digits among all integers from 11 to nn.
390
216
7
7
1000000000
387420489
In the first example the maximum product is achieved for 389389 (the product of digits is 3⋅8⋅9=2163⋅8⋅9=216).
In the second example the maximum product is achieved for 77 (the product of digits is 77).
In the third example the maximum product is achieved for 999999999999999999 (the product of digits is 99=38742048999=387420489).
给一个数n 输出1-n之内数位乘积最大的乘积。
这个题目最方便的方法就是递归，边递归边比较，可以避免888这样近两位比较出现888优于799的情况。
#include<bits/stdc++.h> using namespace std; typedef long long ll; const int maxn=2e5+5; const int INF=1e9+5; typedef pair<int,int> pii; int d[maxn],vis[maxn],cnt[maxn],pre[maxn],sum[maxn],val[maxn]; vector<pii> e[maxn]; int n,k; int cmp(int n) { if(n==0) return 1; else if(n<10) return n; else return max(n%10*cmp(n/10),9*cmp(n/10-1)); } int main() { char s[15]; cin>>n; cout<<cmp(n)<<endl; return 0; }
You are given a rooted tree with vertices numerated from 11 to nn. A tree is a connected graph without cycles. A rooted tree has a special vertex named root.
Ancestors of the vertex ii are all vertices on the path from the root to the vertex ii, except the vertex ii itself. The parent of the vertex ii is the nearest to the vertex ii ancestor of ii. Each vertex is a child of its parent. In the given tree the parent of the vertex ii is the vertex pipi. For the root, the value pipi is −1−1.
An example of a tree with n=8n=8, the root is vertex 55. The parent of the vertex 22 is vertex 33, the parent of the vertex 11 is vertex 55. The ancestors of the vertex 66 are vertices 44 and 55, the ancestors of the vertex 77 are vertices 88, 33 and 55
You noticed that some vertices do not respect others. In particular, if ci=1ci=1, then the vertex ii does not respect any of its ancestors, and if ci=0ci=0, it respects all of them.
You decided to delete vertices from the tree one by one. On each step you select such a non-root vertex that it does not respect its parent and none of its children respects it. If there are several such vertices, you select the one with the smallest number. When you delete this vertex vv, all children of vv become connected with the parent of vv.
An example of deletion of the vertex 77.
Once there are no vertices matching the criteria for deletion, you stop the process. Print the order in which you will delete the vertices. Note that this order is unique.
The first line contains a single integer nn (1≤n≤1051≤n≤105) — the number of vertices in the tree.
The next nn lines describe the tree: the ii-th line contains two integers pipi and cici (1≤pi≤n1≤pi≤n, 0≤ci≤10≤ci≤1), where pipi is the parent of the vertex ii, and ci=0ci=0, if the vertex ii respects its parents, and ci=1ci=1, if the vertex ii does not respect any of its parents. The root of the tree has −1−1 instead of the parent index, also, ci=0ci=0 for the root. It is guaranteed that the values pipi define a rooted tree with nn vertices.
In case there is at least one vertex to delete, print the only line containing the indices of the vertices you will delete in the order you delete them. Otherwise print a single integer −1−1.
5 3 1 1 1 -1 0 2 1 3 0
1 2 4
5 -1 0 1 1 1 1 2 0 3 0
-1
8 2 1 -1 0 1 0 1 1 1 1 4 0 5 1 7 0
5
The deletion process in the first example is as follows (see the picture below, the vertices with ci=1ci=1 are in yellow):
- first you will delete the vertex 11, because it does not respect ancestors and all its children (the vertex 22) do not respect it, and 11 is the smallest index among such vertices;
- the vertex 22 will be connected with the vertex 33 after deletion;
- then you will delete the vertex 22, because it does not respect ancestors and all its children (the only vertex 44) do not respect it;
- the vertex 44 will be connected with the vertex 33;
- then you will delete the vertex 44, because it does not respect ancestors and all its children (there are none) do not respect it (vacuous truth);
- you will just delete the vertex 44;
- there are no more vertices to delete.
In the second example you don't need to delete any vertex:
- vertices 22 and 33 have children that respect them;
- vertices 44 and 55 respect ancestors.
In the third example the tree will change this way:
#include<bits/stdc++.h> using namespace std; typedef long long ll; const int maxn=2e5+5; const int INF=1e9+5; typedef pair<int,int> pii; int d[maxn],vis[maxn],cnt[maxn],pre[maxn],sum[maxn],val[maxn]; vector<pii> e[maxn]; int n,k; int res[maxn]; int c[maxn]; int main() { cin>>n; for(int i=0;i<=n;i++) res[i]=1; for(int i=1;i<=n;i++) { int x,y; cin>>x>>y; if(y==1) c[i]=1; if(y==0) res[x]=0; } int cnt=0; for(int i=1;i<=n;i++) { if(res[i]==1 && c[i]==1) cout<<i<<" ",cnt++; } if(cnt==0) cout<<"-1"<<endl; return 0; }