CodeForces - 598C 598D //Nearest vectors// Igor In the Museum

C. Nearest vectors

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

You are given the set of vectors on the plane, each of them starting at the origin. Your task is to find a pair of vectors with the minimal non-oriented angle between them.

Non-oriented angle is non-negative value, minimal between clockwise and counterclockwise direction angles. Non-oriented angle is always between 0 and π. For example, opposite directions vectors have angle equals to π.

Input

First line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of vectors.

The i-th of the following n lines contains two integers xi and yi (|x|, |y| ≤ 10 000, x2 + y2 > 0) — the coordinates of the i-th vector. Vectors are numbered from 1 to n in order of appearing in the input. It is guaranteed that no two vectors in the input share the same direction (but they still can have opposite directions).

Output

Print two integer numbers a and b (a ≠ b) — a pair of indices of vectors with the minimal non-oriented angle. You can print the numbers in any order. If there are many possible answers, print any.

Examples

input

4
-1 0
0 -1
1 0
1 1

output

3 4

input

6
-1 0
0 -1
1 0
1 1
-4 -5
-4 -6

output

6 5

根据弧度排个序，扫一遍就好了

如果用acos求弧度需要long double  ，如果用atan求只需要double，主要就卡在精度问题

#include<bits/stdc++.h>
using namespace std;
struct node
{
    long double ve;
    int index;
}num[100005];
int cmp(node u ,node v)
{
    return u.ve<v.ve;
}
int main()
{
    int n,i,x,y;
    long double minn,t;
    scanf("%d",&n);
    for(i=1;i<=n;i++)
    {
        scanf("%d %d",&x,&y);
        t=sqrt(x*x+y*y);
        t=x/t;
        if(y<0)
        {
            num[i].ve=2*acos(-1.0)-acos(t);
        }
        else
        {
            num[i].ve=acos(t);
        }
        num[i].index=i;
    }
    sort(num+1,num+n+1,cmp);
    int ans1,ans2;
    minn=1000;
    num[n+1].ve=num[1].ve+2.0*acos(-1.0);
    num[n+1].index=num[1].index;
    for(i=2;i<=n+1;i++)
    {
        t=num[i].ve-num[i-1].ve;
        if(t>acos(-1.0))
            t=2.0*acos(-1.0)-t;
     //  printf("%.30lf %.30lf\n",t,2.0*acos(-1.0));
        if(minn>t)
        {
            minn=t;
            ans1=num[i].index;
            ans2=num[i-1].index;
        }
    }

    printf("%d %d\n",ans1,ans2);
    return 0;
}
/*4
-6427 6285
-5386 5267
3898 -7239
3905 -7252*/

D. Igor In the Museum

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Igor is in the museum and he wants to see as many pictures as possible.

Museum can be represented as a rectangular field of n × m cells. Each cell is either empty or impassable. Empty cells are marked with '.', impassable cells are marked with '*'. Every two adjacent cells of different types (one empty and one impassable) are divided by a wall containing one picture.

At the beginning Igor is in some empty cell. At every moment he can move to any empty cell that share a side with the current one.

For several starting positions you should calculate the maximum number of pictures that Igor can see. Igor is able to see the picture only if he is in the cell adjacent to the wall with this picture. Igor have a lot of time, so he will examine every picture he can see.

Input

First line of the input contains three integers n, m and k (3 ≤ n, m ≤ 1000, 1 ≤ k ≤ min(n·m, 100 000)) — the museum dimensions and the number of starting positions to process.

Each of the next n lines contains m symbols '.', '*' — the description of the museum. It is guaranteed that all border cells are impassable, so Igor can't go out from the museum.

Each of the last k lines contains two integers x and y (1 ≤ x ≤ n, 1 ≤ y ≤ m) — the row and the column of one of Igor's starting positions respectively. Rows are numbered from top to bottom, columns — from left to right. It is guaranteed that all starting positions are empty cells.

Output

Print k integers — the maximum number of pictures, that Igor can see if he starts in corresponding position.

Examples

input

5 6 3
******
*..*.*
******
*....*
******
2 2
2 5
4 3

output

6
4
10

input

4 4 1
****
*..*
*.**
****
3 2

output

8

不难的一个bfs，一直t在memset上，每次bfs是不需要memset标记数组的，只要你记录一下，每个点就只需要扫一次了

#include<bits/stdc++.h>
using namespace std;
char mapp[1005][1005];
bool book[1005][1005],visit[1005][1005];
int anss[1005][1005];
int n,m;
struct node
{
    int x,y;
}road[1000000];
int ne[4][2]={0,1,0,-1,1,0,-1,0};
int check(node t)
{
    if(t.x<1||t.x>n||t.y<1||t.y>m||book[t.x][t.y])
        return 1;
    return 0;
}
int bfs(node beginn)
{
    int ans=0;
    node re,pe;
    int i,j=0;
    book[beginn.x][beginn.y]=1;
    queue<node>q;
    q.push(beginn);
    while(!q.empty())
    {
        re=q.front();
        road[j++]=re;
        visit[re.x][re.y]=1;
        q.pop();
        for(i=0;i<4;i++)
        {
            pe=re;
            pe.x+=ne[i][0];
            pe.y+=ne[i][1];
            if(mapp[pe.x][pe.y]=='*')
            {
                ans++;
                continue;
            }
            if(check(pe))
                continue;
            book[pe.x][pe.y]=1;
            q.push(pe);
        }
    }
    for(i=0;i<j;i++)
    anss[road[i].x][road[i].y]=ans;
   // printf("haha%d %d %d\n",beginn.x,beginn.y,ans); 
    return 0;
}
int main()
{
    int k,i,x,y,j;
    node beginn;
    scanf("%d %d %d",&n,&m,&k);
    for(i=1;i<=n;i++)
        scanf("%s",mapp[i]+1);

    for(i=1;i<=n;i++)
    {
        for(j=1;j<=m;j++)
        {
            if(mapp[i][j]=='.'&&visit[i][j]==0)
            {
                beginn.x=i;
                beginn.y=j;
                bfs(beginn);
            }
        }
    }
    while(k--)
    {
        scanf("%d %d",&x,&y);
        printf("%d\n",anss[x][y]);
    }
    return 0;
}

其实这两个题都不是很难，错就错在方法选择上，在代码实现之前，应好好想想选择的方法是否可行