原题地址：http://acm.hdu.edu.cn/showproblem.php?pid=5881

Tea

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 451    Accepted Submission(s): 124

Problem
Description

Tea is good.
Tea is life.
Tea is everything.
The balance of tea is a journey of pursuing balance of the universe.
Alice knows that.
Alice wants to teach you the art of pouring tea.
Alice has a pot of tea.
The exact volume of tea is not important.
The exact volume of tea is at least L.
The exact volume of tea is at most R.
Alice put two empty cups between you and her.
Alice wants the two cups filled by almost equal volume of tea.
Yours cannot be 1
unit more than hers.
Hers cannot be 1
unit more than yours.
Alice wants you to pour the tea.
Alice wants you to pour until the pot is almost empty.
Alice wants no more than 1
unit volume of tea remaining in the pot.
You cannot read the residue volume of tea remaining in the pot.
You can only know the tea status in the pot, empty or not.
Alice does not want you to pour the tea too many times.
You better pour as few times as possible.

Input

There are multiple cases.
For each case, there is one line of two integers L
and R,
separated by single space.

Here are some analyses about sample cases.
For the first case, pouring 1 unit into one cup will
satisfy Alice.
For the second case, it is clearly that you cannot only pour once to reach the
desired balance, but she can achieve it by pouring twice.
First you pour 1.5
units into one cup, then you attempt to pour another 1.5
units into the other cup.
Since the lower bound is 2,
at least 0.5
unit remains in the pot after the first pouring.
If the initial volume is in range [2,3],
the second cup will have volume in range [0.5,1.5]
which is balanced with 1.5
unit in the first cup, and at most 1
unit remain after these two attempts.

About 1000
test cases, and 0≤L≤R≤1016.

Output

For each case, there should be a single
integer in a single line, the least number of pouring attempts.

Sample
Input

2 2

2 4

Sample Output

1

2

Source

2016 ACM/ICPC Asia Regional Qingdao Online

题意：

从茶壶里向两个杯子里倒茶，茶壶里茶的体积 在[L,R]区间，我们只知道有没有倒完，但不知道还剩多少。

最后两个杯子里茶的差量不能超过1，茶壶里不能剩下超过1。问最少倒几次。

解：

R<=1 茶壶里剩下不超过1，不用倒，0次。

R<=2  从茶壶里向某一个杯子倒 1，两个杯子里茶的差量最大为1，茶壶里剩下的最多为1。倒1次。

L==R或者L==R-1 ，从茶壶里分别向两个杯子倒 L/2 , 倒2次。

L==0或者L==1情况相同。

R>L+1时，先向一个杯子倒L/2,再向另一个倒L/2+1, 再轮流重复向两个杯子里倒2，直到倒完（最多剩下1）.

#include<stdio.h>
#include <algorithm>
#include <cstring>
#include <string.h>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <cstdio>
#include <cmath>

#define LL long long

using namespace std;
LL l,r;

LL solve(LL l,LL r)
{
    if(r<=1) return 0;
    if(r<=2) return 1;
    if(l==r||l==r-1) return 2;
    if(l<=1) l=1;
    return (r-l)/2+1;
}

int main()
{
    while(scanf("%lld%lld",&l,&r)!=EOF)
        {
            cout<<solve(l,  r)<<endl;
        }
    return 0;
}