Codeforces暑期训练周报（8.22~8.28）

最新推荐文章于 2024-08-03 21:32:38 发布

BrilliantWilliam

最新推荐文章于 2024-08-03 21:32:38 发布

阅读量403

点赞数 1

分类专栏：假期养成计划文章标签： Codeforces acm竞赛算法 c++

本文链接：https://blog.csdn.net/weixin_50961321/article/details/126461228

版权

假期养成计划专栏收录该内容

16 篇文章 0 订阅

订阅专栏

暑期训练的最后一周，稍微拔高提升一下，把自己薄弱的部分好好的练一下子，像动态规划、树和图这些，至少最基础的东西不能忘了。

C. Kefa and Park

time limit per test: 2 seconds

memory limit per test: 256 megabytes

input: standard input

output: standard output

Kefa decided to celebrate his first big salary by going to the restaurant.

He lives by an unusual park. The park is a rooted tree consisting of n vertices with the root at vertex 1. Vertex 1 also contains Kefa's house. Unfortunaely for our hero, the park also contains cats. Kefa has already found out what are the vertices with cats in them.

The leaf vertices of the park contain restaurants. Kefa wants to choose a restaurant where he will go, but unfortunately he is very afraid of cats, so there is no way he will go to the restaurant if the path from the restaurant to his house contains more than m consecutive vertices with cats.

Your task is to help Kefa count the number of restaurants where he can go.

Input

The first line contains two integers, n and m (2 ≤ n ≤ $10^5$ , 1 ≤ m ≤ n) — the number of vertices of the tree and the maximum number of consecutive vertices with cats that is still ok for Kefa.

The second line contains n integers $a_1,a_2,...,a_n$ , where each $a_i$ either equals to 0 (then vertex i has no cat), or equals to 1 (then vertex i has a cat).

Next n - 1 lines contains the edges of the tree in the format " $x_i y_i$ " (without the quotes) (1 ≤ $x_i$ , $y_i$ ≤ n, $x_i$ ≠ $y_i$ ), where $x_i$ and $y_i$ are the vertices of the tree, connected by an edge.

It is guaranteed that the given set of edges specifies a tree.

Output

A single integer — the number of distinct leaves of a tree the path to which from Kefa's home contains at most m consecutive vertices with cats.

Examples

input

output

input

7 1
1 0 1 1 0 0 0
1 2
1 3
2 4
2 5
3 6
3 7

output

Note

Let us remind you that a tree is a connected graph on n vertices and n - 1 edge. A rooted tree is a tree with a special vertex called root. In a rooted tree among any two vertices connected by an edge, one vertex is a parent (the one closer to the root), and the other one is a child. A vertex is called a leaf, if it has no children.

Note to the first sample test:

The vertices containing cats are marked red. The restaurants are at vertices 2, 3, 4. Kefa can't go only to the restaurant located at vertex 2.

Note to the second sample test:

The restaurants are located at vertices 4, 5, 6, 7. Kefa can't go to restaurants 6, 7.

题解：

这是一个树上dfs的题目，可以算是个模板题。题目要求不能连续出现超过m个红色的点，所以最基础的想法是dfs整个树。餐厅在叶子节点处，所以dfs终止的条件就是遍历到了叶子节点，利用vector邻接表的方式建图，我们可以在dfs过程中设置一个flag，用于标记是否为叶子节点（也可以用v[i].size()==1来判断），如果满足条件则ans++。需要注意的是，递归dfs的时候，如果没有连续的（即a[v]==0），则要重新开始记录cat的数量。

AC代码：

#include <bits/stdc++.h>
#define BUFF ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define ll long long
#define endl '\n'
#define F(i,st,ed) for(int i=st;i<ed;i++)
#define f(i,ed,st) for(int i=ed-1;i>=st;i--)
#define M(x) memset(x,0,sizeof(x))
#define pb push_back
#define PI acos(-1)
using namespace std;

ll ksc(ll a,ll b,ll mod){
	ll res=0;
	while (b){
		if (b&1){
			res=(res+a)%mod;
		}
		a=(a+a)%mod;
		b>>=1;
	}
	return res;
}
ll ksm(ll a,ll b,ll mod){
	ll res=1;
	while (b){
		if (b&1){
			res=(res*a)%mod;
		}
		a=(a*a)%mod;
		b>>=1;
	}
	return res;
}
const int N=1e5+5;
vector<int> g[N];
int a[N];
ll ans=0;
int n,m;
bool vis[N];
void dfs(int u,int cat){
	if (cat>m){
		return;
	}
	vis[u]=1;
	bool f=0;
	F(i,0,g[u].size()){
		int v=g[u][i];
		if (!vis[v]){
			f=1;
			if (a[v]){
				dfs(v,cat+1);
			}
			else{
				dfs(v,0);
			}
		}
	}
	if (!f){
		ans++;
	}
}
void solve(){
	M(vis);
	cin>>n>>m;
	F(i,1,n+1){
		cin>>a[i];
	}
	F(i,0,n-1){
		int x,y;
		cin>>x>>y;
		g[x].pb(y);
		g[y].pb(x);
	}
	ans=0;
	dfs(1,a[1]);
	cout<<ans<<endl;
}
int main()
{
	BUFF;
	int _;
	//cin>>_;
	_=1; 
	F(i,0,_){
		solve();
	}
	return 0;
}

A. Two Substrings

time limit per test: 2 seconds

memory limit per test: 256 megabytes

input: standard input

output: standard output

You are given string s. Your task is to determine if the given string s contains two non-overlapping substrings "AB" and "BA" (the substrings can go in any order).

Input

The only line of input contains a string s of length between 1 and $10^5$ consisting of uppercase Latin letters.

Output

Print "YES" (without the quotes), if string s contains two non-overlapping substrings "AB" and "BA", and "NO" otherwise.

Examples

input

ABA

output

NO

input

BACFAB

output

YES

input

AXBYBXA

output

NO

Note

In the first sample test, despite the fact that there are substrings "AB" and "BA", their occurrences overlap, so the answer is "NO".

In the second sample test there are the following occurrences of the substrings: BACFAB.

In the third sample test there is no substring "AB" nor substring "BA".

题解：

一道非常简单的字符串的题目。首先，如果字符串中没有“AB”或“BA”的话，答案一定是NO；其他的情况需要简单的分析一下，像ABA……AB这样的形式，如果只用s.find()去做，会出现很大的问题，所以我们采用一位一位的去遍历字符串，第一遍查看"AB"，第二遍查看"BA"，这样可以保证不会漏掉某种情况。

AC代码：

#include <bits/stdc++.h>
#define BUFF ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define ll long long
#define endl '\n'
#define F(i,st,ed) for(int i=st;i<ed;i++)
#define f(i,ed,st) for(int i=ed-1;i>=st;i--)
#define M(x) memset(x,0,sizeof(x))
#define pb push_back
#define PI acos(-1)
using namespace std;

ll ksc(ll a,ll b,ll mod){
	ll res=0;
	while (b){
		if (b&1){
			res=(res+a)%mod;
		}
		a=(a+a)%mod;
		b>>=1;
	}
	return res;
}
ll ksm(ll a,ll b,ll mod){
	ll res=1;
	while (b){
		if (b&1){
			res=(res*a)%mod;
		}
		a=(a*a)%mod;
		b>>=1;
	}
	return res;
}

void solve(){
	string s;
	cin>>s;
	int pos1=s.find("AB");
	int pos2=s.find("BA");
	if (pos1==-1||pos2==-1){
		cout<<"NO"<<endl;
		return;
	}
	int idx=-1;
	bool f1=0,f2=0;
	F(i,0,s.length()){
		if (s[i]=='A'&&s[i+1]=='B'){
			idx=i;
			break;
		}
	}
	F(i,0,s.length()){
		if (i==idx-1||i==idx+1){
			continue;
		}
		if (s[i]=='B'&&s[i+1]=='A'){
			f1=1;
			break;
		}
	}
	idx=-1;
	F(i,0,s.length()){
		if (s[i]=='B'&&s[i+1]=='A'){
			idx=i;
			break;
		}
	}
	F(i,0,s.length()){
		if (i==idx-1||i==idx+1){
			continue;
		}
		if (s[i]=='A'&&s[i+1]=='B'){
			f2=1;
			break;
		}
	}
	//cout<<f1<<" "<<f2<<endl;
	cout<<((f1==1||f2==1)?"YES":"NO")<<endl;
}
int main()
{
	BUFF;
	int _;
	//cin>>_;
	_=1; 
	F(i,0,_){
		solve();
	}
	return 0;
}

B. Ternary String

time limit per test: 2 seconds

memory limit per test: 256 megabytes

input: standard input

output: standard output

You are given a string s such that each its character is either 1, 2, or 3. You have to choose the shortest contiguous substring of s such that it contains each of these three characters at least once.

A contiguous substring of string s is a string that can be obtained from s by removing some (possibly zero) characters from the beginning of s and some (possibly zero) characters from the end of s.

Input

The first line contains one integer t (1≤t≤20000) — the number of test cases.

Each test case consists of one line containing the string s (1≤|s|≤200000). It is guaranteed that each character of s is either 1, 2, or 3.

The sum of lengths of all strings in all test cases does not exceed 200000.

Output

For each test case, print one integer — the length of the shortest contiguous substring of s containing all three types of characters at least once. If there is no such substring, print 0 instead.

Example

input

7
123
12222133333332
112233
332211
12121212
333333
31121

output

Note

Consider the example test:

In the first test case, the substring 123 can be used.

In the second test case, the substring 213 can be used.

In the third test case, the substring 1223 can be used.

In the fourth test case, the substring 3221 can be used.

In the fifth test case, there is no character 3 in ss.

In the sixth test case, there is no character 1 in ss.

In the seventh test case, the substring 3112 can be used.

题解：

一道很好的贪心题目。题目要求输出最小的子串长度，保证这个子串至少包含1、2、3各一次。显然，如果字符串中并没有1、2、3中的任何一个，答案就是0；对于有答案的所有情况，我们可以记录一下每一个满足条件的子串，取最小的那个就可以。

AC代码：

#include <bits/stdc++.h>
#define BUFF ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define ll long long
#define endl '\n'
#define F(i,st,ed) for(int i=st;i<ed;i++)
#define f(i,ed,st) for(int i=ed-1;i>=st;i--)
#define M(x) memset(x,0,sizeof(x))
#define pb push_back
#define PI acos(-1)
using namespace std;

ll ksc(ll a,ll b,ll mod){
	ll res=0;
	while (b){
		if (b&1){
			res=(res+a)%mod;
		}
		a=(a+a)%mod;
		b>>=1;
	}
	return res;
}
ll ksm(ll a,ll b,ll mod){
	ll res=1;
	while (b){
		if (b&1){
			res=(res*a)%mod;
		}
		a=(a*a)%mod;
		b>>=1;
	}
	return res;
}

void solve(){
	string s;
	cin>>s;
	int ans=2e5+5;
	int a=-1,b=-1,c=-1;
	if (s.find("1")==-1||s.find("2")==-1||s.find("3")==-1){
		cout<<"0"<<endl;
		return;
	}
	F(i,0,s.length()){
		if (s[i]=='1'){
			a=i;
		}
		else if (s[i]=='2'){
			b=i;
		}
		else if (s[i]=='3'){
			c=i;
		}
		if (a!=-1&&b!=-1&&c!=-1){
			ans=min(ans,i+1-min(min(a,b),c));
		}
	}
	cout<<ans<<endl;
}
int main()
{
	BUFF;
	int _;
	cin>>_;
	//_=1; 
	F(i,0,_){
		solve();
	}
	return 0;
}

C. Exams

time limit per test: 1 second

memory limit per test: 256 megabytes

input: standard input

output: standard output

Student Valera is an undergraduate student at the University. His end of term exams are approaching and he is to pass exactly n exams. Valera is a smart guy, so he will be able to pass any exam he takes on his first try. Besides, he can take several exams on one day, and in any order.

According to the schedule, a student can take the exam for the i-th subject on the day number ai. However, Valera has made an arrangement with each teacher and the teacher of the i-th subject allowed him to take an exam before the schedule time on day $b_i$ ( $b_i<a_i$ ). Thus, Valera can take an exam for the i-th subject either on day $a_i$ , or on day $b_i$ . All the teachers put the record of the exam in the student's record book on the day of the actual exam and write down the date of the mark as number $a_i$ .

Valera believes that it would be rather strange if the entries in the record book did not go in the order of non-decreasing date. Therefore Valera asks you to help him. Find the minimum possible value of the day when Valera can take the final exam if he takes exams so that all the records in his record book go in the order of non-decreasing date.

Input

The first line contains a single positive integer n (1 ≤ n ≤ 5000) — the number of exams Valera will take.

Each of the next n lines contains two positive space-separated integers $a_i$ and $b_i$ (1 ≤ $b_i<a_i$ ≤ $10^9$ ) — the date of the exam in the schedule and the early date of passing the i-th exam, correspondingly.

Output

Print a single integer — the minimum possible number of the day when Valera can take the last exam if he takes all the exams so that all the records in his record book go in the order of non-decreasing date.

Examples

input

output

input

output

Note

In the first sample Valera first takes an exam in the second subject on the first day (the teacher writes down the schedule date that is 3). On the next day he takes an exam in the third subject (the teacher writes down the schedule date, 4), then he takes an exam in the first subject (the teacher writes down the mark with date 5). Thus, Valera takes the last exam on the second day and the dates will go in the non-decreasing order: 3, 4, 5.

In the second sample Valera first takes an exam in the third subject on the fourth day. Then he takes an exam in the second subject on the fifth day. After that on the sixth day Valera takes an exam in the first subject.

题解：

一道很简单的结构体排序的题目。题目很长，重点是保证a数组非递减。我们可以用一个结构体存这两个值，按照第一个值从小到大排序，如果相同则按照第二个值从小到大排序。我们用ans记录最后的答案，因为b是小于a的，所以每一次我们尽量能让b小是最好的，即b<ans时，ans=a，如果做不到，就把当前的b赋给ans，最后输出ans即可。

AC代码：

#include <bits/stdc++.h>
#define BUFF ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define ll long long
#define endl '\n'
#define F(i,st,ed) for(int i=st;i<ed;i++)
#define f(i,ed,st) for(int i=ed-1;i>=st;i--)
#define M(x) memset(x,0,sizeof(x))
#define pb push_back
#define PI acos(-1)
using namespace std;

ll ksc(ll a,ll b,ll mod){
	ll res=0;
	while (b){
		if (b&1){
			res=(res+a)%mod;
		}
		a=(a+a)%mod;
		b>>=1;
	}
	return res;
}
ll ksm(ll a,ll b,ll mod){
	ll res=1;
	while (b){
		if (b&1){
			res=(res*a)%mod;
		}
		a=(a*a)%mod;
		b>>=1;
	}
	return res;
}
const int N=5005;
struct node{
	int x,y;
}nod[N];
bool cmp(node a,node b){
	if (a.x!=b.x){
		return a.x<b.x;
	}
	return a.y<b.y;
}
void solve(){
	int n;
	cin>>n;
	F(i,0,n){
		cin>>nod[i].x>>nod[i].y;
	}
	sort(nod,nod+n,cmp);
	ll ans=0;
	F(i,0,n){
		int z=min(nod[i].x,nod[i].y);
		if (z<ans){
			ans=nod[i].x;
		} 
		else{
			ans=z;
		}
	}
	cout<<ans<<endl;
}
int main()
{
	BUFF;
	int _;
	//cin>>_;
	_=1; 
	F(i,0,_){
		solve();
	}
	return 0;
}

B. Dreamoon and WiFi

time limit per test: 1 second

memory limit per test: 256 megabytes

input: standard input

output: standard output

Dreamoon is standing at the position 0 on a number line. Drazil is sending a list of commands through Wi-Fi to Dreamoon's smartphone and Dreamoon follows them.

Each command is one of the following two types:

Go 1 unit towards the positive direction, denoted as '+'
Go 1 unit towards the negative direction, denoted as '-'

But the Wi-Fi condition is so poor that Dreamoon's smartphone reports some of the commands can't be recognized and Dreamoon knows that some of them might even be wrong though successfully recognized. Dreamoon decides to follow every recognized command and toss a fair coin to decide those unrecognized ones (that means, he moves to the 1 unit to the negative or positive direction with the same probability 0.5).

You are given an original list of commands sent by Drazil and list received by Dreamoon. What is the probability that Dreamoon ends in the position originally supposed to be final by Drazil's commands?

Input

The first line contains a string $s_1$ — the commands Drazil sends to Dreamoon, this string consists of only the characters in the set {'+', '-'}.

The second line contains a string $s_2$ — the commands Dreamoon's smartphone recognizes, this string consists of only the characters in the set {'+', '-', '?'}. '?' denotes an unrecognized command.

Lengths of two strings are equal and do not exceed 10.

Output

Output a single real number corresponding to the probability. The answer will be considered correct if its relative or absolute error doesn't exceed $10^{-9}$ .

Examples

input

++-+-
+-+-+

output

1.000000000000

input

+-+-
+-??

output

0.500000000000

input

+++
??-

output

0.000000000000

Note

For the first sample, both $s_1$ and $s_2$ will lead Dreamoon to finish at the same position + 1.

For the second sample, $s_1$ will lead Dreamoon to finish at position 0, while there are four possibilites for $s_2$ : {"+-++", "+-+-", "+--+", "+---"} with ending position {+2, 0, 0, -2} respectively. So there are 2 correct cases out of 4, so the probability of finishing at the correct position is 0.5.

For the third sample, $s_2$ could only lead us to finish at positions {+1, -1, -3}, so the probability to finish at the correct position + 3 is 0.

题解：

一道比较简单的概率题，目前为止我接触到的这种题目很少。题目给定两个字符串，问你第二个字符串最后能走到第一个字符串的位置的概率是多少，考虑到两个字符串最多就10位，直接用递归去写就行，首先统计出第一个字符串最后到达的位置，然后统计所有的情况，即第二个字符串 “?” 的个数。最后第二个字符串递归求解，注意如果不把ans放在全局的话需要加引用来返回ans的值，最后按照要求输出即可。

AC代码：

#include <bits/stdc++.h>
#define BUFF ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define ll long long
#define endl '\n'
#define F(i,st,ed) for(int i=st;i<ed;i++)
#define f(i,ed,st) for(int i=ed-1;i>=st;i--)
#define M(x) memset(x,0,sizeof(x))
#define pb push_back
#define PI acos(-1)
using namespace std;

ll ksc(ll a,ll b,ll mod){
	ll res=0;
	while (b){
		if (b&1){
			res=(res+a)%mod;
		}
		a=(a+a)%mod;
		b>>=1;
	}
	return res;
}
ll ksm(ll a,ll b,ll mod){
	ll res=1;
	while (b){
		if (b&1){
			res=(res*a)%mod;
		}
		a=(a*a)%mod;
		b>>=1;
	}
	return res;
}
const int mod=998244353;
const int N=5e4+5;

void judge(string s,ll &ans,ll goal,int idx,ll cur){
	if (idx==s.length()){
		if (cur==goal){
			ans++;
		}
		return;
	}
	if (s[idx]=='+'){
		judge(s,ans,goal,idx+1,cur+1);
	}
	else if (s[idx]=='-'){
		judge(s,ans,goal,idx+1,cur-1);
	}
	else{
		judge(s,ans,goal,idx+1,cur+1);
		judge(s,ans,goal,idx+1,cur-1);
	}
}
void solve(){
	string s1,s2;
	cin>>s1>>s2;
	ll goal=0;
	F(i,0,s1.length()){
		if (s1[i]=='+'){
			goal++;
		}
		else{
			goal--;
		}
	}
	ll ans=0,cnt=0,g2=0;
	F(i,0,s2.length()){
		if (s2[i]=='?'){
			cnt++;
		}
		else if (s2[i]=='+'){
			g2++;
		}
		else{
			g2--;
		}
	}
	judge(s2,ans,goal,0,0);
	cout<<fixed<<setprecision(9)<<1.0*ans/pow(2,cnt)<<endl;
}
int main()
{
	BUFF;
	int _;
	//cin>>_;
	_=1; 
	F(i,0,_){
		solve();
	}
	return 0;
}

C. Make It Good

time limit per test: 1 second

memory limit per test: 256 megabytes

input: standard input

output: standard output

You are given an array a consisting of n integers. You have to find the length of the smallest (shortest) prefix of elements you need to erase from a to make it a good array. Recall that the prefix of the array $a=[a_1,a_2,...,a_n]$ is a subarray consisting several first elements: the prefix of the array a of length k is the array $[a_1,a_2,...,a_k]$ (0≤k≤n).

The array b of length m is called good, if you can obtain a non-decreasing array c ( $c_1\leq c_2\leq...\leq c_m$ ) from it, repeating the following operation m times (initially, c is empty):

select either the first or the last element of b, remove it from b, and append it to the end of the array c.

For example, if we do 4 operations: take $b_1$ , then $b_m$ , then $b_{m-1}$ and at last $b_2$ , then b becomes $[b_3,b_4,...,b_{m-3}]$ and $c=[b_1,b_m,b_{m-1},b_2]$ .

Consider the following example: b=[1,2,3,4,4,2,1]. This array is good because we can obtain non-decreasing array c from it by the following sequence of operations:

take the first element of b, so b=[2,3,4,4,2,1], c=[1];
take the last element of b, so b=[2,3,4,4,2], c=[1,1];
take the last element of b, so b=[2,3,4,4], c=[1,1,2];
take the first element of b, so b=[3,4,4], c=[1,1,2,2];
take the first element of b, so b=[4,4], c=[1,1,2,2,3];
take the last element of b, so b=[4], c=[1,1,2,2,3,4];
take the only element of b, so b=[], c=[1,1,2,2,3,4,4] — c is non-decreasing.

Note that the array consisting of one element is good.

Print the length of the shortest prefix of a to delete (erase), to make a to be a good array. Note that the required length can be 0.

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1≤t≤2⋅ $10^4$ ) — the number of test cases. Then t test cases follow.

The first line of the test case contains one integer n (1≤n≤2⋅ $10^5$ ) — the length of a. The second line of the test case contains n integers $a_1,a_2,...,a_n$ (1≤ $a_i$ ≤2⋅ $10^5$ ), where $a_i$ is the i-th element of a.

It is guaranteed that the sum of n does not exceed 2⋅ $10^5$ (∑n≤2⋅ $10^5$ ).

Output

For each test case, print the answer: the length of the shortest prefix of elements you need to erase from a to make it a good array.

Example

input

5
4
1 2 3 4
7
4 3 3 8 4 5 2
3
1 1 1
7
1 3 1 4 5 3 2
5
5 4 3 2 3

output

Note

In the first test case of the example, the array a is already good, so we don't need to erase any prefix.

In the second test case of the example, the initial array a is not good. Let's erase first 4 elements of a, the result is [4,5,2]. The resulting array is good. You can prove that if you erase fewer number of first elements, the result will not be good.

题解：

这个题目看着很长，实际上并不困难，对于c数组的数字，我们需要从b数组的第一个或者最后一个元素中选择一个插入到c中，最后使得c数组非递减。首先，如果数组是已经排好序的，那么答案一定是0；其他的情况，我们需要找到最后一个“山峰形状”的连续序列，这样能保证这个c一定是非递减的序列，所以我们可以从后向前遍历数组，找到第一个“山峰”之后，如果还出现了递增，直接break掉循环即可。

AC代码：

#include <bits/stdc++.h>
#define BUFF ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define ll long long
#define endl '\n'
#define F(i,st,ed) for(int i=st;i<ed;i++)
#define f(i,ed,st) for(int i=ed-1;i>=st;i--)
#define M(x) memset(x,0,sizeof(x))
#define pb push_back
#define PI acos(-1)
#define MOD 1e9+7
using namespace std;

ll ksc(ll a,ll b,ll mod){
	ll res=0;
	while (b){
		if (b&1){
			res=(res+a)%mod;
		}
		a=(a+a)%mod;
		b>>=1;
	}
	return res;
}
ll ksm(ll a,ll b,ll mod){
	ll res=1;
	while (b){
		if (b&1){
			res=(res*a)%mod;
		}
		a=(a*a)%mod;
		b>>=1;
	}
	return res;
}
const int mod=998244353;
const int N=2e5+5;
ll a[N];
void solve(){
	int n;
	cin>>n;
	F(i,0,n){
		cin>>a[i];
	}
	if (is_sorted(a,a+n)){
		cout<<"0"<<endl;
		return;
	}
	int ans=0;
	bool f=0;
	f(i,n,1){
		if (a[i]>a[i-1]){
			f=1;
		}
		if (f&&a[i]<a[i-1]){
			ans=i;
			break;
		}
	}
	cout<<ans<<endl;
}
int main()
{
	BUFF;
	int _=1;
	cin>>_;
	F(i,0,_){
		solve();
	}
	return 0;
}