Your friend has recently learned about coprime numbers. A pair of numbers{a,?b} is called coprime if the maximum number that divides both a andb is equal to one.

Your friend often comes up with different statements. He has recently supposed that if the pair(a,?b) is coprime and the pair (b,?c) is coprime, then the pair (a,?c) is coprime.

You want to find a counterexample for your friend‘s statement. Therefore, your task is to find three distinct numbers(a,?b,?c), for which the statement is false, and the numbers meet the conditionl?≤?a?<?b?<?c?≤?r.

More specifically, you need to find three numbers(a,?b,?c), such that l?≤?a?<?b?<?c?≤?r, pairs (a,?b) and (b,?c) are coprime, and pair(a,?c) is not coprime.

The single line contains two positive space-separated integersl, r (1?≤?l?≤?r?≤?10¹⁸;r?-?l?≤?50).

Print three positive space-separated integers a, b, c — three distinct numbers (a,?b,?c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.

If the counterexample does not exist, print the single number -1.

In the first sample pair (2,?4) is not coprime and pairs(2,?3) and (3,?4) are.

In the second sample you cannot form a group of three distinct integers, so the answer is -1.

In the third sample it is easy to see that numbers900000000000000009 and 900000000000000021 are divisible by three.

简单构造：第一个数和第二个数互素，第二个数和第三个数互素，第一个数和第三个数不互素，显然找偶奇偶序列

#include <cstdio>
#define ll long long
ll gcd(ll a, ll b) 
{
    return b ? gcd(b, a % b) : a;  
}
int main()
{
    ll a, b;
    ll ans[3] = {0};
    scanf("%I64d %I64d", &a, &b);
    if(b == a + 1)
    {
        printf("-1\n");
        return 0;
    }
    if(a % 2 == 1)
    {
        ans[0] = a + 1;
        ans[1] = a + 2;
    }
    else
    {
        ans[0] = a;
        ans[1] = a + 1;   
    }
    for(ll i = a + 2; i <= b; i++)
    {
        if(gcd(ans[1], i) == 1 && gcd(ans[0], i) != 1)
        {
            ans[2] = i;
            break;
        }
    }
    if(ans[2] == 0)
    {
        printf("-1\n");
        return 0;
    }
    printf("%I64d %I64d %I64d\n", ans[0], ans[1], ans[2]);
}

3 1 2 3

5

1 3 2 3

4

构造两个序列，第一个序列要有cnt1个数且其中不能有x的倍数，第二个序列要有cnt2个数且其中不能有y的倍数。要求求出这两个序列中的最大数的最小值。

如果答案是ans则ans＋1也满足可以发现问题满足二分做法的条件，cnt1个数为num - num / x，及1到num中不包含x倍数的数的个数，同理

cnt2个数为num - num / y，还有一点要注意的是必须满足cnt1 + cnt2 <= num - num / (x * y)因为题目要求两个集合中的元素不同，又因为x，y必然互素，所以cnt1和cnt2的和必须小于1到num中不包含(x * y)倍数的数的个数，不然两个集合必然出现重复元素，然后二分num的值便可以得到最终答案。

#include <cstdio>
int cal(int a, int b)
{
    return a - a / b;
}
int main()
{
    int cnt1, cnt2, x, y;
    scanf("%d %d %d %d", &cnt1, &cnt2, &x, &y);
    int l = 1, r = 2e9;         
    while(l < r)
    {              
        int mid = l + (r - l) / 2;
        if(cnt1 <= cal(mid, x) && cnt2 <= cal(mid, y) && cnt1 + cnt2 <= cal(mid, x * y))
            r = mid;
        else
            l = mid + 1;
    }
    printf("%d\n", r);  
}

3 2

1 3 2

3 1

1 2 3

5 2

1 3 2 4 5

一个包含n个数的数列，要求相邻两元素差的绝对值的数的个数为k，要求构造这样的数列。

简单的构造题，k－－并变号判断即可

#include <cstdio>
#include <cstring>
int const MAX = 1e5 + 5;
int a[MAX];
int hash[MAX];
int main()
{
    int n, k;
    scanf("%d %d", &n, &k);
    memset(hash, 0, sizeof(hash));
    a[1] = 1;
    hash[a[1]] = 1;
    int cnt = 1;
    for(int i = 2; i <= n; i++)
    {
        cnt++;
        a[i] = a[i - 1] + k;
        hash[a[i]] = 1;
        if(k > 0)
            k--;
        else
            k++;
        k *= -1;
        if(k == 0)
            break;
    }
    for(int i = 1; i <= n; i++)
        if(!hash[i])
            a[++cnt] = i;
    for(int i = 1; i < n; i++)
        printf("%d ", a[i]);
    printf("%d\n", a[n]);

}

3 1
1 3 3

YES
3 3 3

3 2
1 3 3
1 3 2

NO

题意如题，还是构造数列，线段树维护＋判断

#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
int const MAX = 110000;
struct Node
{
    int l, r;
    int val;
};
Node tree[10 * MAX];
Node a[MAX];
vector<int> ans;

void build(int step, int l, int r)
{
    tree[step].l = l;
    tree[step].r = r;
    tree[step].val = 0;
    if(l == r)
        return;
    int mid = (l + r) >> 1;
    build(step << 1, l, mid);
    build(((step << 1) + 1), mid+1, r);
}
void update(int step, int l, int r, int val)
{
    if(tree[step].l == l && tree[step].r == r)
    {
        tree[step].val |= val;
        return;
    }
    int mid = (tree[step].l + tree[step].r) >> 1;
    if(r <= mid)
        update(step << 1, l, r, val);
    else if(l > mid)
        update((step << 1) + 1, l, r, val);
    else
    {
        update(step << 1, l, mid, val);
        update((step << 1) + 1, mid+1, r, val);
    }
}
int query(int step, int l, int r)
{
    if(tree[step].l == l && tree[step].r == r)
        return tree[step].val;
    int mid = (tree[step].l + tree[step].r) >> 1;
    if(r <= mid)
        return query(step << 1, l, r);
    if(l > mid)
        return query((step << 1) + 1, l, r);
    else
        return query(step << 1, l, mid) & query((step << 1) + 1, mid+1, r);
}
void solve(int step)
{
    if(step != 1)
        tree[step].val |= tree[step >> 1].val;
    if(tree[step].l == tree[step].r)
    {
        ans.push_back(tree[step].val);
        return ;
    }
    solve(step << 1);
    solve((step << 1) + 1);
}
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    build(1, 1, n);
    for(int i = 0; i < m; i++)
    {
        scanf("%d %d %d", &a[i].l, &a[i].r, &a[i].val);
        update(1, a[i].l, a[i].r, a[i].val);
    }
    bool flag = true;
    for(int i = 0; i < m; i++)
    {
        if(query(1, a[i].l, a[i].r) != a[i].val)
        {
            flag = false;
            break;
        }
    }
    solve(1);
    if(flag)
    {
        printf("YES\n");
        for(int i = 0; i < ans.size(); i++)
            printf("%d%c",ans[i], i == n ? '\n' : ' ');
        ans.clear();
        printf("\n");
    }
    else
        printf("NO\n");
}