*HDU 2451 数学

Simple Addition Expression

Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1723    Accepted Submission(s): 675

Problem Description

A
luxury yacht with 100 passengers on board is sailing on the sea in the
twilight. The yacht is ablaze with lights and there comes out laughers
and singing from the hall where an evening party is in full swing.
People are singing, dancing and enjoying themselves.

The yacht is
equipped with the most advanced navigation and driving system which can
all be manipulated by a computer. When the captain notices that there
is only gentle breeze and the sea waves are not high, he starts the
autopilot. The yacht sails forward smoothly, ploughs the waves. When
it’s completely dark, the passengers start to feel a little funny for
sudden forward rushes or sudden decelerations or slight swings. The
captain immediately walks to the driving platform and switches the
autopilot to human manipulation. The yacht returns back to normal and
the party restarts. Laughers come back, too.

The captain summons
the engineer on board to do a thorough check of the navigation system.
It turns out that only the computer is out of order, but the exact
failure is still unclear. There is a computer scientist among the
passengers who is also invited to the cab to give a hand. He first
inputs several groups of data to test the computer. When he inputs
1+2+3, the computer outputs 6, which is exactly right. But when he
inputs 4+5+6, the computer outputs 5, which is wrong. Then he inputs
12+13+14, and gets 39, another right answer, while he inputs 14+15+16,
and gets 35, another wrong answer. After the test, the computer
scientist says smilingly: “the failure is clear now. The computer's
adder can not carry." After excluding the failure, the captain restarts
the autopilot and the yacht returns back to normal, sailing smoothly on
the sea.

The captain and the engineer invite the computer
scientist to sit down and have a talk. The computer scientist tells a
story as following:

A former mathematician defined a kind of simple addition expression.
If
there is an expression (i) + (i+1) + (i+2), i>=0, when carried out
additive operations, no position has a carry, it is called simple
addition expression.

For instance, when i equals 0, 0+1+2 is a
simple addition expression, meanwhile when i equals 11, 11+12+13 is a
simple addition expression, too. Because of that no position has a
carry.

However, when i equals 3, 3+4+5 is not a simple addition
expression, that is because 3+4+5 equals 12, there is a carried number
from unit digit to tens digit. In the same way, when i equals 13,
13+14+15 is not a simple addition expression, either. However, when i
equals 112, 112+113+114 is a simple addition expression. Because
112+113+114 equals 339, there is no carry in the process of adding.

when
the students have got the definition of simple addition expression, the
mathematician puts forward a new question: for a positive integer n,
how many simple addition expressions exist when i<n. In addition, i
is the first number of a simple addition expression.

when the value of n is large enough, the problem needs to be solved by means of computer.

 

Input

There are several test cases, each case takes up a line, there is an integer n (n<10^10).

 

Output

Output the number of all simple addition expressions when i<n.

 

Sample Input

1
2
3
4
10
11

 

Sample Output

1
2
3
3
3
4

 

Source

2008 Asia Regional Harbin

 

题意：

问小于n的数i中i+i+1+i+2不会产生进位的i有多少个。

代码：

 //最近一段时间被数学搞晕了，各种烦躁，迷糊。这道题可以把数拆开来，首位可以取1,2,3，中间可以取0,1,2,3，最后一位可以取0,1,2。有多少个i,比如拆2345，
 //先计算0~999有多少个，再计算1000~1999有多少个,再计算2000上面0~99,100~199,200~299有多少个，再计算300上面........如果第一位大于3，比如4321，那么他
 //和9999没什么区别，中间的几位也是同样的道理。
 #include<bits\stdc++.h>
 #define ll long long
 using namespace std;
 char s[];
 ll f[];
 int main()
 {
     f[]=;f[]=; //10以下的有几个，下面的同理
     for(int i=;i<=;i++)
     {
         f[i]=*f[i-];
     }
     while(scanf("%s",s)!=EOF)
     {
         ll ans=;
         int len=strlen(s);
         for(int i=;i<len;i++)
         {
             if(i==&&i!=len-)
             {
                 if(s[i]-''>)
                 {ans+=f[len-i];break;}
                 else ans+=(s[i]-'')*f[len-i-];
             }
             else if(i!=&&i!=len-)
             {
                 if(s[i]-''>)
                 {ans+=f[len-i];break;}
                 else ans+=(s[i]-'')*f[len-i-];
             }
             else if(i==len-)
             ans+=s[i]-''>?:s[i]-'';
         }
         printf("%lld\n",ans);
     }
     return ;
 }