Simple Addition Expression Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1524    Accepted Submission(s): 579

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
题目分析：
求解的是三个连续的数相加不需要进位的数的组合的种类
那么我们首先考虑三个连续的数的性质首先，开头数的个位数字一定不会超过2，因为2,3,4的和已经达到9了，因为从十位开始是三个相同的数字，所以不超过3即可，只有最高位不能为０，那么我们开一个数组num记录第几位不受任何限制能够组成的数的个数，然后再算取结果时，对于一个数，从最高位开始，如果出现大于4的数字，那么可以加上num[当前位]，然后跳出循环即可，因为所有可能都涵盖了，如果不大于4，那么就是当前数字固定，当前位取比当前数小的任何数，后面的位都能取所有情况，然后后面再看在前面位都固定的情况下，能够得到的可能的数字，知道最后一位，因为是<n的所以要特判一下不能最后一个数字等于给定位的数字 
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define MAX 20

using namespace std;

typedef long long LL;

LL num[MAX];
int digit[MAX];
int cnt;

void init ( )
{
    num[1] = 3;
    for ( int i = 2 ; i <= 12 ; i++ )
            num[i] = num[i-1]*4L;
}

LL n;

int main ( )
{
    init();
    while ( ~scanf ( "%lld" , &n ) )
    {
        cnt = 1;
        while ( n )
        {
            digit[cnt++] = n%10;
            n /= 10;
        }
        LL ans = 0;
        bool flag = true;
        for ( int i = cnt-1 ; i > 1 ; i-- )
        {
            int k = digit[i];
            if ( k < 4 )
                ans += num[i-1]*k;
            else 
            {
                ans += num[i];
                flag = false;
                break;
            }
        }
        if ( flag ) ans += min ( digit[1] , 3 );
        printf ( "%lld\n" , ans );
    } 
}