C++博客-Yuan-随笔分类-组合数学

CF54C

_Yuan — Wed, 04 May 2011 17:06:00 GMT

/*
    区间[L,R]中每个数出现的概率为1/(R-L+1)
    现给出n个区间，[Li,Ri]，每个区间抽取出一个数
    求这n个数中，至少有K%个数的前缀为1的概率

    可以处理出每个区间[Li, Ri]抽取的数前缀为1的概率p[i]
    dp[i,j]表示前面i个区间有j个数前缀为1的概率
    则转移就是dp[i,j] = dp[i-1,j-1]*p[i]  + dp[i-1,j]*(1-p[i])
    答案就是∑dp[n,j]， j/n >= K%
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>
#include<bitset>

using namespace std;

long long cal(long long x) {//[1,x]
    long long cnt = 0 , now = 1;
    while(x/now > 1) {
        cnt += now;
        now *= 10;
    }
    if(x / now == 1) {//x = 1***
        cnt += x - now + 1;
    }
    return cnt;
}

double cal(long long left, long long right) {
    return (cal(right) - cal(left-1)) / (right - left + 1.0);
}

double p[1000], dp[1000][1000];

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    for (int n; ~scanf("%d", &n); ) {
        long long left, right;
        for (int i = 0; i <n ; i++) {
            scanf("%I64d%I64d", &left, &right);
            p[i] = cal(left, right);
        }
        memset(dp, 0, sizeof dp);
        dp[0][0] = 1.0;
        for (int i = 1; i <= n; i++) {
            for(int j = 0; j <= i; j++) {
                dp[i][j] = dp[i-1][j-1]*p[i-1] + dp[i-1][j]*(1-p[i-1]);
            }
        }
        int per;
        scanf("%d", &per);
        double ans = 0;
        for( int j = 0 ; j <= n; j++ ) {
            if(100*j >= n*per) {
                ans += dp[n][j];
            }
        }
        printf("%.10f\n", ans);
    }
    return 0;
}

_Yuan 2011-05-05 01:06 发表评论

八中 1833 zjoi 2010 count

_Yuan — Wed, 23 Mar 2011 05:32:00 GMT

/*
    求[a,b]中0-9各数字出现的次数    <=10^12

    一开始我用数位统计搞
    想按照这种方法搞的
    http://www.cppblog.com/Yuan/archive/2011/01/25/139299.html
    搞了好久搞不出，逐渐发现dfs型的写法，状态一般需要(pos,pre)，需要压缩前缀为pre
    我定义(pos, preCnt)
    preCnt是表示前缀中有多少个数字跟当前要检查的数字相同，不行的，不能正确表示出前缀!
    如12,21记录1出现的个数都是一样的，但是结果不同
    会被if(dp[pos][pre] != -1)
        return dp[pos][pre]
    返回错误的结果

    这个前缀应该具有共用性，也就说不同前缀压缩得到的结果有些要一样，这样才能记忆化嘛，重复利用！！
    但这题，前缀如果是直接用前面的数字来表示的话，很多，肯定时空都不行


    所以，搞数位统计，需要记录前缀（数位统计不记录应该前缀不行吧）
    同时前缀必须是能区分（不会返回错误结果）的，还要可共用（用来减少运算，提高速度）

    这道题的正确做法，换做以前，可能会想到，但是现在感觉思维定势了T_T
    参考http://hi.baidu.com/736551725/blog/item/8ba4408e4fb74206b21bbae4.html
    观察下表
    000
    001
    .
    998
    999
    对于长度为3的，总共有3*10^3个数字，每个数字出现的概率一样，所以每个数字出现的次数为3*10^3/10
    也即宽度为n的表，每个数字出现的次数为n*10^(n-1)
    对于前缀0，要去掉，对于宽度为n的表，前缀0的个数为11..1个（表的左上角那些0，包括000那个）

    有了上面的观察，就逐位统计下，就能得到[1,n]各个数字出现的次数了
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>

using namespace std;

void gao(__int64 n,  __int64 cnt[]){//count all digits in [1,n] , not [0,n]
    /*
    check a form like this .
        000
        001
        .
        010
        .
        099
        100
        101   ------N
    */
    int digit[20], num = 0;
    __int64 p = 1, N = n, sub = 0;
    do{
        digit[num++] = n % 10;
        n /= 10;
        p *= 10;
    }while(n > 0);
    for(int i = num - 1,j ; i >= 0 ; i --){
        p /= 10;
        for(j = 0 ; j < digit[i] ; j++){
            cnt[j] += p;
            for(int k = 0; k < 10 ; k++){
                cnt[k] += p/10*i;
            }
        }
        N %= p;
        cnt[j] += N+1;//要加1
        sub += p;
    }
    cnt[0] -= sub;
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("in","r",stdin);
#endif

    for(__int64 left, right ; cin >> left >> right; ){
        __int64 cnt[10] = {0};
        gao(left-1, cnt);
        for(int i = 0 ; i < 10 ; i++){
            cnt[i] = -cnt[i];
        }
        gao(right, cnt);
        for(int i = 0; i < 10 ; i++){
            if(i){
                putchar(' ');
            }
            printf("%I64d", cnt[i]);
        }
        puts("");
    }
    return 0;
}

_Yuan 2011-03-23 13:32 发表评论

hdu 3398 进栈出栈计数 n!质因子分解

_Yuan — Tue, 22 Mar 2011 07:02:00 GMT

/*
    给出n个1，m个0，组成一个串，要求这个串的任意前缀都有1的个数>=0的个数
    求满足这样的串的个数
    n,m <= 10^6

    脑残丫，很明显的“进栈出栈”，居然没反应
    计数公式为
        (n+m, m) - (n+m, m-1)

            (n+m)!(n-m+1)
    =    ------------------
           (n+1)!m!

    O(n)的计算会超时，要对N!分解质因子
    用到公式N!里质因子p的个数为 N/p + N/p^2 +

    这要注意别忘记对(n-m+1)分解质因子了，如果放在最后来乘它的话，有可能对某个质因子p，只用那三个算到的
    幂小于0，而20100501又不是素数，就难算 p^x % 20100501  , x < 0
    因为欧拉定理 a^x % n = a ^(x % phi(n) ) % n 需要 (a,n) = 1！！！！
    八中 1856跟这题一样，不过那里的20100403是素数，可以那样搞 p^x

    参考
    http://hi.baidu.com/matrush/blog/item/5298d8a3786b478546106447.html
*/
#include<iostream>
#include<cstring>
#include<map>
#include<algorithm>
#include<stack>
#include<queue>
#include<cmath>
#include<string>
#include<cstdlib>
#include<vector>
#include<cstdio>
#include<set>
#include<list>
#include<numeric>
#include<cassert>
#include<ctime>

using namespace std;

const int MOD = 20100501;
const int MAXN = 2000000;

bool isPrime[MAXN+10];
int pr[MAXN] , tot;

void init(){
    for(__int64 p = 2 ; p < MAXN ; p ++){
        if(!isPrime[p]){
            pr[tot++] = p;
            for(__int64 j = p * p ; j < MAXN ; j += p){
                isPrime[j] = true;
            }
        }
    }
}

/*
    1*2**n
    tot = n/p , n/p^2 ,
*/
int get(int p, int n){
    int tot = 0;
    while(n > 0){
        tot += n / p;
        n /= p;
    }
    return tot;
}

int ipow(int a , int n){
    if ( n == 0 ) {
        return 1;
    }
    if (n ==1 ) {
        return a % MOD;
    }
    __int64 ans = ipow(a, n/2);
    ans = ans * ans % MOD;
    if ( n&1 ) {
        ans = ans * a % MOD;
    }
    return ans;
}

int solve(int n, int m){
    if(n < m){
        return 0;
    }
    /*
        (n+m)!(n-m+1)
        ------------------
            m!(n+1)!
    */
    __int64 ans = 1;
    int nm = n - m + 1;
    for(int i = 0 ; i < tot && pr[i] <= (n+m) ; i++){
        int cnt = 0;
        while(nm % pr[i] == 0){
            nm /= pr[i];
            cnt++;
        }
        ans = ans * ipow(pr[i], get(pr[i], n+m) - get(pr[i], m) - get(pr[i], n+1) + cnt) % MOD;
    }
    return ans;
}

int main()
{
#ifndef ONLINE_JUDGE
    //freopen("in","r",stdin);
#endif
    init();
    int T;
    for (scanf("%d",&T); T-- ; ) {
        int n, m;
        scanf("%d%d", &n, &m);
        printf("%d\n", solve(n,m));
    }
    return 0;
}

_Yuan 2011-03-22 15:02 发表评论