Codeforces Round #499 (Div. 2) 1011 D. Rocket

D. Rocket

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

This is an interactive problem.

Natasha is going to fly to Mars. Finally, Natasha sat in the rocket. She flies, flies... but gets bored. She wishes to arrive to Mars already! So she decides to find something to occupy herself. She couldn't think of anything better to do than to calculate the distance to the red planet.

Let's define xx as the distance to Mars. Unfortunately, Natasha does not know xx. But it is known that 1≤x≤m1≤x≤m, where Natasha knows the number mm. Besides, xx and mm are positive integers.

Natasha can ask the rocket questions. Every question is an integer yy (1≤y≤m1≤y≤m). The correct answer to the question is −1−1, if x<yx<y, 00, if x=yx=y, and 11, if x>yx>y. But the rocket is broken — it does not always answer correctly. Precisely: let the correct answer to the current question be equal to tt, then, if the rocket answers this question correctly, then it will answer tt, otherwise it will answer −t−t.

In addition, the rocket has a sequence pp of length nn. Each element of the sequence is either 00 or 11. The rocket processes this sequence in the cyclic order, that is 11-st element, 22-nd, 33-rd, ……, (n−1)(n−1)-th, nn-th, 11-st, 22-nd, 33-rd, ……, (n−1)(n−1)-th, nn-th, ……. If the current element is 11, the rocket answers correctly, if 00 — lies. Natasha doesn't know the sequence pp, but she knows its length — nn.

You can ask the rocket no more than 6060 questions.

Help Natasha find the distance to Mars. Assume, that the distance to Mars does not change while Natasha is asking questions.

Your solution will not be accepted, if it does not receive an answer 00 from the rocket (even if the distance to Mars is uniquely determined by the already received rocket's answers).

Input

The first line contains two integers mm and nn (1≤m≤1091≤m≤109, 1≤n≤301≤n≤30) — the maximum distance to Mars and the number of elements in the sequence pp.

Interaction

You can ask the rocket no more than 6060 questions.

To ask a question, print a number yy (1≤y≤m1≤y≤m) and an end-of-line character, then do the operation flush and read the answer to the question.

If the program reads 00, then the distance is correct and you must immediately terminate the program (for example, by calling exit(0)). If you ignore this, you can get any verdict, since your program will continue to read from the closed input stream.

If at some point your program reads −2−2 as an answer, it must immediately end (for example, by calling exit(0)). You will receive the "Wrong answer" verdict, and this will mean that the request is incorrect or the number of requests exceeds 6060. If you ignore this, you can get any verdict, since your program will continue to read from the closed input stream.

If your program's request is not a valid integer between −231−231 and 231−1231−1 (inclusive) without leading zeros, then you can get any verdict.

You can get "Idleness limit exceeded" if you don't print anything or if you forget to flush the output.

To flush the output buffer you can use (after printing a query and end-of-line):

• fflush(stdout) in C++;
• System.out.flush() in Java;
• stdout.flush() in Python;
• flush(output) in Pascal;
• See the documentation for other languages.

Hacking

Use the following format for hacking:

In the first line, print 33 integers m,n,xm,n,x (1≤x≤m≤1091≤x≤m≤109, 1≤n≤301≤n≤30) — the maximum distance to Mars, the number of elements in the sequence pp and the current distance to Mars.

In the second line, enter nn numbers, each of which is equal to 00 or 11 — sequence pp.

The hacked solution will not have access to the number xx and sequence pp.

Example

input

Copy

5 2
1
-1
-1
1
0

output

Copy

1
2
4
5
3

Note

In the example, hacking would look like this:

5 2 3

1 0

This means that the current distance to Mars is equal to 33, Natasha knows that it does not exceed 55, and the rocket answers in order: correctly, incorrectly, correctly, incorrectly ...

Really:

on the first query (11) the correct answer is 11, the rocket answered correctly: 11;

on the second query (22) the correct answer is 11, the rocket answered incorrectly: −1−1;

on the third query (44) the correct answer is −1−1, the rocket answered correctly: −1−1;

on the fourth query (55) the correct answer is −1−1, the rocket answered incorrectly: 11;

on the fifth query (33) the correct and incorrect answer is 00.

 

题意：

猜数字x 1<=x<=m 。 你每次可以猜y 系统会给你一个答案 -1 1 或0 。

-1相当于 x<y ，1相当于x>y, 0相当于 x=y 。如果你猜中即x==y，会强制退出程序 那你就答对啦

当然系统可是很调皮的噢，给你的答案可能是错的也可能是对的

存在一个长度为n的01序列，010101，0代表第一次系统给的答案是错误的，原本应该给-1，却给了1，或者原本给1却给了-1。

系统会循环的根据这个序列给答案。

最终要求猜出正确答案（可以猜60次噢）

 

 

思路：

这题眨眼一看交互性的 OMG我就遇到过一次 那次也是不会做

这道题的题意我大概看了快20分钟还是每理解完 然后滚去睡美容觉了

刚刚和队友讨论了一下怎么才能得出正确的01序列 沃特？？前n次输入1就可以把01序列搞出来！！！

记录下01序列（最多询问30次） 

剩下的就是二分正确答案了 最少剩下30次 妥妥的

问题1：第二次做这种交互,用printf输出会错误 不知道为什么 用cout正确

问题2:scanf就可以获得系统给的答案 题目中说了一大串的fflush给我搞蒙了

#include <cstdio>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <vector>
#include <iostream>
#define ll long long
#define INF 0x3f3f3f
using namespace std;
const int N=300000+1000;
int a[N];
int main()
{
    int n,m,i,l,r,cnt,mid,temp;
    scanf("%d%d",&m,&n);
    for(i=0;i<n;i++)
    {
        cout<<1<<endl;
        scanf("%d",&temp);
        if(temp==-1) a[i]=0;
        else a[i]=1;
        if(temp==0) return 0;
    }
    l=2;r=m;
    cnt=0;
    while(l<r)
    {
        mid=(l+r)/2;
        cout<<mid<<endl;
        scanf("%d",&temp);
        if(temp==0) return 0;
        if(temp==-1)
        {
            if(a[cnt%n]==0) l=mid+1;
            else r=mid;
        }
        else
        {
            if(a[cnt%n]==0) r=mid;
            else l=mid+1;
        }
        cnt++;
    }
    mid=(l+r)/2;
    cout<<mid<<endl;
    return 0;
}