F. Mentors

F. Mentors
time limit per test3 seconds
memory limit per test256 megabytes
inputstandard input
outputstandard output
In BerSoft
n
programmers work, the programmer
i
is characterized by a skill
r
i
.

A programmer
a
can be a mentor of a programmer
b
if and only if the skill of the programmer
a
is strictly greater than the skill of the programmer
b

(
r
a
>
r
b
)
and programmers
a
and
b
are not in a quarrel.

You are given the skills of each programmers and a list of
k
pairs of the programmers, which are in a quarrel (pairs are unordered). For each programmer
i
, find the number of programmers, for which the programmer
i
can be a mentor.

Input
The first line contains two integers
n
and
k

(
2
≤
n
≤
2
⋅
10
5
,
0
≤
k
≤
min
(
2
⋅
10
5
,
n
⋅
(
n
−
1
)
2
)
)
— total number of programmers and number of pairs of programmers which are in a quarrel.

The second line contains a sequence of integers
r
1
,
r
2
,
…
,
r
n

(
1
≤
r
i
≤
10
9
)
, where
r
i
equals to the skill of the
i
-th programmer.

Each of the following
k
lines contains two distinct integers
x
,
y

(
1
≤
x
,
y
≤
n
,
x
≠
y
)
— pair of programmers in a quarrel. The pairs are unordered, it means that if
x
is in a quarrel with
y
then
y
is in a quarrel with
x
. Guaranteed, that for each pair
(
x
,
y
)
there are no other pairs
(
x
,
y
)
and
(
y
,
x
)
in the input.

Output
Print
n
integers, the
i
-th number should be equal to the number of programmers, for which the
i
-th programmer can be a mentor. Programmers are numbered in the same order that their skills are given in the input.

Examples
inputCopy
4 2
10 4 10 15
1 2
4 3
outputCopy
0 0 1 2
inputCopy
10 4
5 4 1 5 4 3 7 1 2 5
4 6
2 1
10 8
3 5
outputCopy
5 4 0 5 3 3 9 0 2 5
Note
In the first example, the first programmer can not be mentor of any other (because only the second programmer has a skill, lower than first programmer skill, but they are in a quarrel). The second programmer can not be mentor of any other programmer, because his skill is minimal among others. The third programmer can be a mentor of the second programmer. The fourth programmer can be a mentor of the first and of the second programmers. He can not be a mentor of the third programmer, because they are in a quarrel.

#include<stdio.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
int b[200010],n,m,i;
struct node
{
   int p,ans;
}a[200010];
bool cmp(int x,int y)
{
    return x<y;
}
void searchp()
{
    //int n,m;//这个地方，全局变量啊全局变量全局变量，如果再重新定义一遍，就只能在这个函数里用了，在主函数里相当于这里没有输入M,怪不得输不进去矛盾关系
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++)
    {
        scanf("%d",&a[i].p);
        b[i]=a[i].p;
    }
    sort(b+1,b+1+n,cmp);
    for(i=1;i<=n;i++)
    {
        struct node k=a[i];
        a[i].ans=lower_bound(b+1,b+1+n,k.p)-b-1;
    }
}
int main()
{
    searchp();
    while(m--)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if(a[x].p<a[y].p)
        {
            a[y].ans--;
        }
        else if(a[y].p<a[x].p)
        {
            a[x].ans--;
        }
    }
    for(i=1;i<=n;i++)
    {
        printf("%d ",a[i].ans);
    }
    return 0;
}

题意：就是说找*，只能是能力大的人领导能力小的人，相等都不行，所以先把能力排好序，在二分查找找出每个人能管多少个人，二分查找就是先把要找的数排好序放大一个数组里，然后对这个数组进行操作，决定是用upper_bound还是lower_bound，对这个题来说，如果能力相等，这个是不能领导的，所以要减1，然后查找出有几个可以领到的小跟班，最后再处理矛盾关系，有矛盾关系的那就能力大的人少一个小跟班，最后输出能力；
小结：就是考的二分查找
以下为转载：