SRM 510 2 250TheAlmostLuckyNumbersDivTwo(数位dp)

SRM 510 2 250TheAlmostLuckyNumbersDivTwo

---

Problem Statement

John and Brus believe that the digits 4 and 7 are lucky and all others are not. According to them, an almost lucky number is a number that contains at most one non-lucky digit in its decimal representation. Return the total number of almost lucky numbers between a and b, inclusive.

Definition

• ClassTheAlmostLuckyNumbersDivTwo
• Methodfind
• Parametersint , int
• Returnsint
• Method signatureint find(int a, int b)

(be sure your method is public)

Limits

• Time limit (s)2.000
• Memory limit (MB)64

Constraints

• a will be between 1 and 1,000,000, inclusive.
• b will be between a and 1,000,000, inclusive.

Test cases

0.  

   • a4
   • b7

    

   Returns4

    

   All numbers between 4 and 7 are almost lucky.
1.  

   • a8
   • b19

    

   Returns4

    

   Numbers 8, 9, 14 and 17 are almost lucky.
2.  

   • a28
   • b33

    

   Returns0

    

   No almost lucky numbers here.
3.  

   • a1234
   • b4321

    

   Returns36

---

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.

#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <typeinfo>
#include <fstream>

using namespace std;
int dp[10][10] , dp2[10][10];
int dig[10] ;
int vis[10] ;

void init ()
{
    memset (dp , 0 , sizeof(dp)) ;
    memset (dp2 , 0 , sizeof(dp2) ) ;
    for (int i = 0 ; i < 10 ; i ++) dp[1][i] = 1 ;
    for (int i = 2 ; i <= 7 ; i ++ ) {
        for (int j = 0 ; j < 10 ; j ++) {
          dp[i][j] += dp[i-1][4] + dp[i-1][7] ;
        }
    }
    int a , b , c = 0 , d = 0 ;
    for (int i = 1 ; i <= 7 ; i ++) for (int j = 0 ; j < 10 ; j ++) dp2[i][j] = dp[i][j] ;
    for (int i = 2 ; i <= 7 ; i ++) {
        a = dp[i][4] , b = dp[i][7] ;
        for (int j = 0 ; j < 10 ; j ++) {
            if (!(j == 4 || j == 7)) {
                dp2[i][4] += dp[i-1][j] ;
                dp2[i][7] += dp[i-1][j] ;
            }
            else if (j == 4) {
                dp2[i][4] += c ;
                dp2[i][7] += c ;
            }
            else if (j == 7) {
                dp2[i][4] += d ;
                dp2[i][7] += d ;
            }
        }
   //    printf ("dp[%d][4]=%d , dp[%d][7]=%d
" , i , dp[i][4] , i , dp[i][7]) ;
        c = dp2[i][4] - a , d = dp2[i][7] - b ;
    }
}

int cal (int x)
{
    memset (dig , 0 , sizeof(dig)) ;
    memset (vis , 0 , sizeof(vis)) ;
    int ans = 0 ;
    int len = 1 ;
    int tmp = x ;
    int cnt = 0 ;
    while (x) {
        dig[len ++] = x % 10 ;
        x /= 10 ;
    }
    for (int i = len - 1 ; i >= 1 ; i --) {
        vis[i] = cnt ;
        if (dig[i] != 4 && dig[i] != 7) cnt ++ ;
    }
    //for (int i = 0 ; i < dig[1] ; i ++) ans += dp[1][i] ;
 //   ans += 10 ;
  //  printf ("hahaha") ;
  //  printf ("%d " , vis[0]) ;
   // for (int i = 1 ; i < len ; i ++) printf ("%d " , vis[i]) ; puts ("") ;
    for (int i = 1 ; i < len  ; i ++) {
       printf ("vis[%d]=%d:

" , i , vis[i] ) ;
        if (vis[i] == 0 ) {
            for (int j = 0 ; j < dig[i] ; j ++) ans += dp2[i][j] ;
        }
        else if (vis[i] == 1) {
            for (int j = 0 ; j < dig[i] ; j ++) if (j == 4 || j == 7) ans += dp[i][j]  , printf ("dp[%d][%d]=%d
" , i , j , dp[i][j]) ;
        }
        if (i == len -1 ) ans -= dp[i][0] ;
    }
    printf ("ans = %d
" , ans ) ;
    if (len == 2) {
        ans += dp[1][0] ;
    }
    else {
        ans += dp[1][0] ;
        for (int i = 1 ; i < len - 1 ; i ++) {
            for (int j = 1 ; j < 10 ; j ++) ans += dp2[i][j] ;
        }
    }
    printf ("%d:ans = %d
" , tmp , ans) ;
    printf ("-----------------------------------
") ;
    return ans ;
}

class TheAlmostLuckyNumbersDivTwo {
    public:
    int find(int a, int b) {
        puts ("") ;
        if (a > b) swap(a,b) ;
        init () ;
        printf ("%d ~ %d
" , a , b) ;
     //   printf ("%d - %d
" , cal(b) , cal(a-1)) ;
        return cal(b+1) - cal(a) ;
        //return 0 ;
    }
};

// CUT begin
ifstream data("TheAlmostLuckyNumbersDivTwo.sample");

string next_line() {
    string s;
    getline(data, s);
    return s;
}

template <typename T> void from_stream(T &t) {
    stringstream ss(next_line());
    ss >> t;
}

void from_stream(string &s) {
    s = next_line();
}

template <typename T>
string to_string(T t) {
    stringstream s;
    s << t;
    return s.str();
}

string to_string(string t) {
    return """ + t + """;
}

bool do_test(int a, int b, int __expected) {
    time_t startClock = clock();
    TheAlmostLuckyNumbersDivTwo *instance = new TheAlmostLuckyNumbersDivTwo();
    int __result = instance->find(a, b);
    double elapsed = (double)(clock() - startClock) / CLOCKS_PER_SEC;
    delete instance;

    if (__result == __expected) {
        cout << "PASSED!" << " (" << elapsed << " seconds)" << endl;
        return true;
    }
    else {
        cout << "FAILED!" << " (" << elapsed << " seconds)" << endl;
        cout << "           Expected: " << to_string(__expected) << endl;
        cout << "           Received: " << to_string(__result) << endl;
        return false;
    }
}

int run_test(bool mainProcess, const set<int> &case_set, const string command) {
    int cases = 0, passed = 0;
    while (true) {
        if (next_line().find("--") != 0)
            break;
        int a;
        from_stream(a);
        int b;
        from_stream(b);
        next_line();
        int __answer;
        from_stream(__answer);

        cases++;
        if (case_set.size() > 0 && case_set.find(cases - 1) == case_set.end())
            continue;

        cout << "  Testcase #" << cases - 1 << " ... ";
        if ( do_test(a, b, __answer)) {
            passed++;
        }
    }
    if (mainProcess) {
        cout << endl << "Passed : " << passed << "/" << cases << " cases" << endl;
        int T = time(NULL) - 1435285921;
        double PT = T / 60.0, TT = 75.0;
        cout << "Time   : " << T / 60 << " minutes " << T % 60 << " secs" << endl;
        cout << "Score  : " << 250 * (0.3 + (0.7 * TT * TT) / (10.0 * PT * PT + TT * TT)) << " points" << endl;
    }
    return 0;
}

int main(int argc, char *argv[]) {
    cout.setf(ios::fixed, ios::floatfield);
    cout.precision(2);
    set<int> cases;
    bool mainProcess = true;
    for (int i = 1; i < argc; ++i) {
        if ( string(argv[i]) == "-") {
            mainProcess = false;
        } else {
            cases.insert(atoi(argv[i]));
        }
    }
    if (mainProcess) {
        cout << "TheAlmostLuckyNumbersDivTwo (250 Points)" << endl << endl;
    }
    return run_test(mainProcess, cases, argv[0]);
}
// CUT end

数位dp,,,,蛮有趣的，写了我三天，还好现在是考试季。数位dp能大大减少复杂度，拿这道题来说。如果用暴力来做要O(1e6),但用数位dp来的话，只需O(70)!!!!!

但同时换来的是复杂的构造。

推荐：http://www.cnblogs.com/archimedes/p/numerical-digit-dp.html