STL 逐个实现一遍。比如stack为啥用deque来实现，而不是其他的容器，
不是vector等等。可以自己手写一遍，就能体验到性能的差距了。

deque是分段数组，分段索引，然后存储，具体实现比较复杂。可以参考
其他STL源码剖析。

一阶正则化和二阶正则化的区别，一界正则化可以处理稀疏性，二届正则化是欧式空间，

当时学的时候，曹旻老师教的n^2, 然后邻接矩阵+静态链表优化复杂度到O(n+e),
但是这个编程不容易实现。

昨晚学神说怎么不做hihocoder，于是赶紧看了一道拓扑排序，基础题了。

之前只会n^2,看到1e5就傻眼了，

然后知道了O(n+e)的方法，用一个入度数组加队列，类似广度优先的算法来做，时间复杂度是O(n+e)

后来炒肉说BFS，我以为是另外一个，然后根据图关系去扩展点，但是写着发现WA了，问了才知道还是根据入度为0的点去扩展的于是乎，就是一种算法。

另外一种基于DFS和栈的算法之前看过geeksforgeeks上有，现在有点忘了。
有时候会忘记clear每个边的数组

cin>>t;
for(int ti=1;ti<=t;ti++)
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) Edge[i].clear();
    for(int i=0;i<m;i++)
    {
        cin>>x>>y;
        Edge[x].push_back(y);
    }
    int InDegree[n+1];
    memset(InDegree, 0, sizeof InDegree);
    for(int i=1;i<=n;i++)
    {
        for(auto e: Edge[i]) InDegree[e]++;
    }
    queue<int> q;
    for(int i=1;i<=n;i++) if(!InDegree[i]) q.push(i);
    int cnt=0;bool ok=1;
    bool v[n+1];
    //memset(v, 0 ,sizeof v);

    while(!q.empty())
    {
        auto cur=q.front();q.pop();cnt++;
        //InDegree[cur]=-1;
        for(auto e: Edge[cur])
        {
            InDegree[e]--;
            if(!InDegree[e]) q.push(e);
        }
        //cout<<cur<<" ";
        //if(v[cur]) {ok=0; break;}
        //v[cur]=1;
        //for(int i=1;i<=n;i++)
    }
    puts( cnt==n ? "Correct" : "Wrong");
}

Posted by richard爱闹 - 5月 25 2015
如需转载，请注明： 本文来自 Richard

13*6=80, 在多少进制下成立。

十进制=78， 进制数应该小于10， 再试9就出来了。

不能只看80然后就确定78在8进制下是80， 这是错误的，为什么呢？

因为不同进制下的乘法表都是不同的！

昨晚CF的D题有点意思，当我学了筛法，遇到Facebook Hackercup R1 Homework时其实我是拒绝的，因为我回了艾式筛法，却不会利用筛法算素数的种类数，看了王超晖代码后才知道可以把01变成整数存储。但是2*i的内循环
is needed.

当我看到昨晚CF D题时，其实我是拒绝的，因为我知道怎么算素因子的种类数，却不会再利用dp来算素因子的个数。对于合数，只要存一个素因子，就可以利用整除以一个素因子之后的数的素因子个数来算这个数的素因子个数, 分治思想真是帅啊。

艾式筛法比较多，其实本题还可以用欧拉筛法，虽然还不太会写code。

看了屌夫同学大背头的代码之后顿悟
PS:

1. 栈的数组申请比较有限，可以用全局的申请更大的数组，比如此处LL的5e6级别的大小
2. B题居然写错了前后减的关系，应该是a[i-1]+1是目标，a[i]是原始，同样的错误在GCJ的一道题目也犯过，尤其是这种存储在一起，特别当心计算顺序的时候，看来还是练习不够，或者就用一个变量存储。

LL dp[maxn+10], n, t, m;
LL P[maxn+10];
void Prime()
{
    memset(P, 0, sizeof P);
    P[1]=1;
    for(LL i=2;i*i<=maxn;i++)
    {
        if(!P[i])
        {
            for(LL j=i*i;j<=maxn;j+=i) P[j]=i;
        }
    }
    //cout<<"zhang";
    dp[1]=dp[2]=dp[3]=1;
    for(LL i=4;i<=maxn;i++)
    {
        if(P[i]) dp[i]=dp[i/P[i]]+1;
        else dp[i]=1;
    }
    for(LL i=2;i<=maxn;i++) dp[i]+=dp[i-1];
    //for(LL i=1;i<=100;i++ ) cout<<dp[i]<<" ";
}

PS:
代码卡着时间过的2.9s, 时限3s，我都不知道开了输入挂是加速呢，还是加速呢，还是加速呢。。。。。

insane 可怕的

story after ID
http://codeforces.com/blog/entry/18021

my id is normal, just richard+zrc(zhang ruichang), richard
sounds similar to my Chinese name, and add suffix just for distinct from others.

How about the story after turmoil, fawkes, ahdoc, shawn. z?

in a row表示连续的

He has been to many countries to participate in IOI (7 years in a row) and also other competitions.

http://acm.hdu.edu.cn/showproblem.php?pid=5233

昨晚BC B题，就是查询。

一开始想着怎么维护代价最小，居然用优先队列，其实id的顺序是递增的，直接顺序存储的数据结构就好了，用队列。但是MLE了，这里多组数据的题目会说一定要用
while(cin), queue可能STL里面的空间开销较大，但是换vector还是T，最后还是拿了学弟的代码A的。

int x,q;
while(n=getint())
{
    m=getint();
myset.clear();
for(int i=0;i<n;i++)
{
    x=getint();
    //Node nd(i+1);
    myset[x].push(i+1);
}
for(int i=0;i<m;i++)
{
    q=getint();
    map<int, queue<int> >:: iterator it=myset.find(q);
    if(it==myset.end()) puts("-1");
    else if(it->second.empty()) puts("-1");
    else
    {
        printf("%d\n", it->second.front());
        it->second.pop();
    }
}
}

另外附上一种编程非常简答的方法，例如，直接把所有query一起处理，最后也就是分别sort两个数组，然后归并，最后再sort按照query顺序打印，这样也TLE，
卡常数，nlgn+mlgm+m+n, 但是常数项大导致TLE了。

对于离线算法往往一起处理可以提高效率。

int x;
while(n=getint())
{
    m=getint();
    for(int i=0;i<n;i++) x=getint(), h[i]=(Node1){x, i+1};
    sort(h, h+n, comp0);
    for(int i=0;i<m;i++) x=getint(), q[i]=(Node2){x, i+1, 0};
    sort(q, q+m, comp1);
    for(int i=0, j=0; i<m && j<n; )
    {
        if(h[i].x<q[j].x) i++;
        else if(h[i].x>q[j].x) q[j++].z=-1;
        else q[j++].z=h[i].y, i++;
    }
    sort(q, q+m, comp2);
    for(int i=0;i<m;i++) printf("%d\n", q[i].z);
}

Posted by richard爱闹 - 5月 24 2015
如需转载，请注明： 本文来自 Richard

计算最长前缀回文子串，可以利用字符串匹配算法KMP的Next数组，然后原串和reverse串拼接之后，算Next，要多算一个，可以采用加一个字符的办法，最后一个Next值就是需要的信息。

写一个函数，可以从给定的概率分布中采样，暂时考虑连续概率分布。

但是，如果从编程角度来实现，似乎不好实现。

这里介绍一个ITM(Inversion Transform Method)算法，
引用自码代码的张洋，该大神用JS轮着实现了一遍这些算法。
http://blog.codinglabs.org/articles/methods-for-generating-random-number-distributions.html

该算法依赖于一个条件就是，概率分布函数需要有反函数

ITM算法描述

1. 生成一个服从均匀分布的随机数U∼Uni(0,1)
2. 设F(X)为指定分布的CDF，F−1(Y)是其逆函数。返回X=F−1(U)作为结果

我们从横轴上标注两点xa和xb，其CDF值分别为F(xa)和F(xb)。

由于U服从0到1之间的均匀分布，因此对于一次U的取样，U落入F(xa)和F(xb)之间的概率为:

P(U∈(F(xa),F(xb)))=F(xb)−F(xa)
而由于CDF都是单调非减函数，因此这个概率同时等于X落入xa和xb之间的概率，即：

P(U∈(F(xa),F(xb)))=P(F−1(U)∈(F−1(F(xa)),F−1(F(xb))))=P(X∈(xa,xb))=F(xb)−F(xa)
而根据CDF的定义，这刚好说明X服从以F(x)为CDF的分布，因此我们的生成算法是正确的。

关键是一个利用反函数来实现的，因为CDF全都是[0,1]之间的值域，
我们需要按照给定分布去采样。

一般来说ITM是一种很好的算法，简单且高效，如果可以使用的话，是第一选择。但是ITM有自身的局限性，就是要求必须能给出CDF逆函数的解析表达式，有些时候要做到这点比较困难，这限制了ITM的适用范围。

当无法给出CDF逆函数的解析表达式时，Acceptance-Rejection Method（下文简称ARM）是另外的选择。ARM的适用范围比ITM要大，只要给出概率密度函数（下文简称PDF）的解析表达式即可，而大多数常用分布的PDF是可以查到的。

ARM算法描述

设PDF为f(x)。首先生成一个均匀分布随机数X∼Uni(xmin,xmax)
独立的生成另一个均匀分布随机数Y∼Uni(ymin,ymax)
如果Y≤f(X)，则返回X，否则回到第1步

Posted by richard爱闹 - 5月 21 2015
如需转载，请注明： 本文来自 Richard

python substring 居然s[2:8]表示s[2…7]
取子串也是end-1这种，和C++迭代器一样。

当初看了知乎帖子，为啥是这样呢
是为了写循环判断出口方便

for(auto e=v.begin(); e!=v.end();e++)
类似这种，虽然现在都有for each语法替代了

GCJ2015 Round1C BrattleShip 战舰

第二题是MinMax理论，我当时想的太复杂度，应该大胆猜测最后一次命中就是最多次的情况，实际也是的。

然后我具体考虑了每一次的策略，却没有打乱猜测的顺序去归纳一个公式出来。

R*C/W+(C%W==0 ? W-1 : W)

就是这么一个公式搞定。

每隔W个猜一次，然后最后把剩余的补全

这题是一个MinMax算法，博弈论里面的一个著名算法。

Posted by richard爱闹 - 5月 18 2015
如需转载，请注明： 本文来自 Richard

解决VS2010 静态编译的问题
http://www.cnblogs.com/zhanjindong/archive/2013/05/15/3080707.html

远程剪贴板失效的解决方案：
http://bugnotes.net/computer-use/clipboard-bug.html

rdpclip.exe 新建一个，如果有kill掉再新建

AI CS6 激活解决方案
http://www.ittribalwo.com/article/2200.html
替换amtlib.dll, 然后如果安装失败，删除commond files adobe caps 下的 三个.db文件，
是之前安装版本残留的东西产生的冲突

iphone4S 不支持移动4G，移动智能2G

iphone从5C/5S才开始支持移动4G,

小米2S纸质GSM和WCDMA，移动只有2G，联通电信有3G，之前一直以为还有2.5G。
2G：0.384Mbps，4G：100Mbps，差距好大啊。不过从QQ里面看，多数还是2GB，主要还是因为手机
不支持吧，然后移动用户还是主流，移动多数又没有3G，而且大家多数都是几年前的手机，因此2G变主流了。

http://zh.wikipedia.org/wiki/2.5G
http://zhidao.baidu.com/question/537057700.html

Linux 下 wc -l 是 计算文件行数的命令

Windows下一直在找寻替代品，终于找到了
速度还行，虽然比不上Linux，但还可以接受

find /V “” /C FileName

http://zhidao.baidu.com/question/62500981.html

auto 用在数组的时候要特别当心，因为数组往往是用size控制需要的内容，而auto是访问申请的数组
所有元素，

cpp如果 goto 语句和 到的 地方之间不能有变量的定义，因为这样怕goto到一个没有定义的变量，
g++编译器相比GCC的新特性 http://www.360doc.com/content/13/0426/10/9057021_281021640.shtml

unordered_set 没有vector 或者数组的 构造函数，可以用另一个 hash作为参数列表

融神发了一个memchr memmem的推

想起来memset(v, 0, sizeof v);memset(v, -1, sizeof v);
都是恰好可以赋值0 -1的，其他的很多都不行，因为每个直接填充刚好和四个字节的补码相等

memchr(p, value, num), 表示从p指向的头num个字节，找char 为value的地址
memmem好像标准STL没有

matlab 清除所有变量除了
clearvars -except Fasta ReadsNum ClusterNum

matlab -nojvm

昨天CF A题写残了，以为要存起点和终点，其实是有信息冗余的，只要存每个起点，然后一段字符串就是两个起点之间的内容。这样不仅去除信息冗余，代码还简单，不容易有bug

Java set.add(i) 如何找到了，返回true，否则返回false
List list=new ArrayList();
list.get(i) 访问元素
python 进行字符减法是不行的，需要转换为int, 然后相减，而cpp是兼容char 和int的，因此可以直接减。
ord(s[0])-ord(‘a’)
反过来转换的有chr(0) 转化为char类型

printf(“%x”, ‘a’);
表示输出十六进制数，%0xd 多输出一个d.

substr()函数，起点是[0, len], 长度没有限制，因为两个参数都是size_t类型，如果>len, 就会当成取
全部字符。所以主要是判起点不要>len就好

tar 打包
tar -cvf ziptest.tar.gz ziptest/

psftp用法如下：

open 10.20.2.26
cd /home
lcd E:\26
get ZRC.tar.gz
put leveldb.

先打开远程连接，然后切换到远程目录，然后切换到本地目录
然后下载文件名

winscp 在本地无法用，可能是Win7的原因

发送邮件：
事实证明，当出现邮箱投递出错，重新投递，任务还在处理队列里，只是要等待，过一天再看说不定就发送成功了，不要再多发一遍了~~~~

vim 学习

非编辑状态

G: 最后一行
gg: 第一行
56G: 表示跳转第56行

/string: 查找string
n表示下一个occurrence
N表示上一个occurrence

把C++11代码改成C++98真是蛋疼啊
编译命令如下：
g++ -o SeqToKmer main.cpp Kmer.cpp Kmeans.cpp EvalPer.cpp

里面都是.cpp 文件，.cpp会自动找.h文件

现在还有一个问题，就是怎么把vim下的内容复制到外面来，一直没有解决。
目前还是直接敲出来了的。。。

另外删除一个字符串

/d似乎有点问题，

python爬虫，盗用了cxlove的代码，其中hdoj的代码部分需要修改
将open部分去掉，如下所示

class HDOJLogin :
    '''
    登录HDOJ
    '''
    def __init__ (self , user , password) :
        self.hosturl = r'http://acm.hdu.edu.cn/'
        self.posturl = r'http://acm.hdu.edu.cn/userloginex.php?action=login'
        self.headers = {'User-Agent':'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:29.0) Gecko/20100101 Firefox/29.0' , 'Refer': 'http://acm.hdu.edu.cn/'}
        self.user = user
        self.password = password
        self.postData = {'username' : self.user , 'userpass' : self.password , 'login': 'Sign In'}

    def main (self) :
        cj = cookielib.LWPCookieJar()
        cookie_support = urllib2.HTTPCookieProcessor (cj)
        opener = urllib2.build_opener (cookie_support , urllib2.HTTPHandler)
        urllib2.install_opener (opener)
        #h = urllib2.urlopen (self.hosturl)
        req = urllib2.Request(self.hosturl, headers=self.headers)
        self.postData = urllib.urlencode(self.postData)
        request = urllib2.Request(self.posturl, self.postData , self.headers)
        response = urllib2.urlopen(request)

Posted by richard爱闹 - 5月 5 2015
如需转载，请注明： 本文来自 Richard

python 没有数组概念，因此用list

例如dp=[], 表示初始一个空list，然后append来扩充。
dp=[0]*n 表示定义一个长为n的数组，初始值为0

linux 重命名文件是 mv
python range(len): 0..len-1
range(start, end):start, end-1
range(start, end, step): start, start+step…end1(<end)

远程连接25的cmd

mstsc /v:10.20.2.25 /admin

最近一直遇到这个问题
Stack Overflow requires external JavaScript from another domain, which is blocked or failed to load
看到别人GCJ第一题用了DP，我怎么没想到，贪心一直贪了半天，最后挂个蛋回家，小数据都没A。有时候就是一条筋走到底，最优化问题首先想DP
http://stackoverflow.com/questions/30008076/codejam-2015-round-1b-counter-culture

StackOverflow一直审核极其严格的，稍有不规范就删帖，封账号。

目前解决方案有下列
http://www.quora.com/Why-does-this-sentenceStack-Overflow-requires-external-JavaScript-from-another-domain-which-is-blocked-or-failed-to-load-appear

但是主要几个都没有解决问题，禁掉USTC的CDN也还是不行。

第一题ON的dp算法还是从一个日本人博客看了，才想到，昨晚完全木有从这里想，觉得第一题就是稍加贪心思想的编程题
http://ijmp320.hatenablog.jp/entry/2015/05/03/135054

查找文件内容

查找目录下的所有文件中是否含有某个字符串
查找目录下的所有文件中是否含有某个字符串
find .|xargs grep -ri “IBM”
查找目录下的所有文件中是否含有某个字符串,并且只打印出文件名
find .|xargs grep -ri “IBM” -l

查找文件名 包含文件名包含3000

find -name ‘3000*.fna’ 找到前缀为3000k 后缀是.fna的文件

CF301Div2ProC

用 DFS 一直T。

改BFS，之前一直都是在取出队列访问，但是这里由于终点要踩两步才算到，因此如果在取出队列访问，那么可能每次放入队列都X，导致一次就认为到了。

这里面适合在扩展的时候 判出口

int main()
{
    iOS;
    while(cin>>m>>n)
    {
        for(int i=0;i<m;i++) cin>>str[i];
        cin>>x1>>y1>>x2>>y2;
        x1--,y1--, x2--, y2--;
        if(x1==x2 && y1==y2 && check(x1, y1)) {puts("YES");continue;}
        queue<Node> q;
        q.push({x1, y1});
        bool ok=0;
        while(!q.empty())
        {
            auto cur=q.front();q.pop();
            //cout<<cur.x<<" "<<cur.y<<"    ";
            for(int k=0;k<4;k++)
            {
                int nx=cur.x+dx[k], ny=cur.y+dy[k];
                if(outrange(nx, ny)) continue;
                if((nx==x2 && ny==y2) && (str[x2][y2]=='X' || check(x2, y2)))
                {
                    //cout<<"cur: "<<nx<<" "<<ny<<str[x2][y2]<<" "<<check(x2, y2)<<endl;
                    ok=1;goto L1;
                }
                //if(cur.x==x2 && cur.y==y2) {ok=1;goto L1;}
                if(str[nx][ny]=='X') continue;
                str[nx][ny]='X';
                q.push({nx, ny});
            }
        }
     L1:puts(ok?"YES":"NO");
    }
    return 0;
}

今天和shawn king讨论这题，我在想为啥一定要在取出队列判出口呢，一开始标记终点是否是X
就可以区分了。

于是写了一个标准BFS，WA了，后来自己举了一个例子，发现了问题，如果有两条长度一样的路，那么最后两条路刚好把路全部变为X，而如果终点是. 那么算法会认为NO，实际是有YES的

int main()
{
/*
#ifndef ONLINE_JUDGE
    freopen ("in.txt" , "r" , stdin);
    freopen ("out.txt" , "w" , stdout);
#endif
*/
    while(cin>>m>>n)
    {
        for(int i=0;i<m;i++) cin>>str[i];
        cin>>x1>>y1>>x2>>y2;x1--, y1--,x2--,y2--;
        queue<Node> q;
        bool EndIsX=(str[x2][y2]=='X');
        //cout<<"End: "<<EndIsX<<endl;
        q.push({x1, y1});
        bool ok=0;
        while(!q.empty())
        {
            auto cur=q.front();q.pop();
            //cout<<cur.x<<" "<<cur.y<<endl;
            if(cur.x==x2 && cur.y==y2 && (EndIsX || Check(x2, y2))) {ok=1;break;}
            for(int k=0;k<4;k++)
            {
                int nx=cur.x+dx[k], ny=cur.y+dy[k];
                if(outrange(nx, ny) || (str[nx][ny]=='X' && (nx!=x2 || ny!=y2)) ) continue;
                str[nx][ny]='X';
                q.push({nx, ny});
            }
        }
        puts(ok?"YES":"NO");
    }
    return 0;
}

于是乎终于知道这题为啥要在扩展节点的时候判出口了，因为这样两条路可以差1，然后就可以在另一条路把.变为X之前找到需要的路径了

while(cin>>m>>n)
{
    for(int i=0;i<m;i++) cin>>str[i];
    cin>>x1>>y1>>x2>>y2;x1--, y1--,x2--,y2--;
    queue<Node> q;
    bool EndIsX=(str[x2][y2]=='X');
    //cout<<"End: "<<EndIsX<<endl;
    q.push({x1, y1});
    bool ok=0;
    while(!q.empty())
    {
        auto cur=q.front();q.pop();
        //cout<<cur.x<<" "<<cur.y<<endl;
        //for(int i=0;i<m;i++) cout<<str[i]<<endl;
        //if(cur.x==x2 && cur.y==y2 && (EndIsX || Check(x2, y2))) {ok=1;break;}
        for(int k=0;k<4;k++)
        {
            int nx=cur.x+dx[k], ny=cur.y+dy[k];
            if(outrange(nx, ny))continue;
            if(nx==x2 && y2==ny && (str[x2][y2]=='X' || Check(x2, y2))) {ok=1;goto L1;}
            if(str[nx][ny]=='X') continue;
            str[nx][ny]='X';
            q.push({nx, ny});
        }
    }
    L1:puts(ok?"YES":"NO");
}

Posted by richard爱闹 - 5月 2 2015
如需转载，请注明： 本文来自 Richard

array a;
a.fill(0);

右值引用

今天看了DTW，http://en.wikipedia.org/wiki/Dynamic_time_warping
目的是匹配两个长度不等，但是轮廓相同的序列的相似度的匹配算法。具体的例子
就是两个人说一个单词，但是语速不同，导致长度不同，因此匹配的位置也不同，因此需要允许扭曲序列，也就是存在偏移的匹配。

int DTWDistance(s: array [1..n], t: array [1..m]) {
DTW := array [0..n, 0..m]

for i := 1 to n
    DTW[i, 0] := infinity
for i := 1 to m
    DTW[0, i] := infinity
DTW[0, 0] := 0

for i := 1 to n
    for j := 1 to m
        cost:= d(s[i], t[j])
        DTW[i, j] := cost + minimum(DTW[i-1, j  ],    // insertion
                                    DTW[i  , j-1],    // deletion
                                    DTW[i-1, j-1])    // match

return DTW[n, m]

}

加上偏移量限制的算法，也就是对于每个i，都是j是从i-w 到i+w计算，其他的不匹配，考虑到i-w可能下越界，因此max(1, i-w), 考虑到i+w上越界，因此min(m, i+w)

今天做RepeatDNASeq 的时候，每个DNA都编码一次，O(10n)，肖哥说可以用位运算，这样可以后面的不用遍历整个dna序列，复杂度降到O(n),

那么每次val都左移2位，然后再取低位的20位，然后累加新来的一个数的值

val<<=2;
val&=m;
val+=GetIndex(s[i+9]);

整个代码如下：

class Solution {
public:
    int GetIndex(char s)
    {
        if(s=='A') return 0;
        if(s=='T') return 1;
        if(s=='G') return 2;
        if(s=='C') return 3;
    }
    vector<string> findRepeatedDnaSequences(string s) {
        int n=s.size();
        unordered_map<int, pair<int, int>> myhash;
        string dna=s.substr(0, 10);
        int val=0;
        for(auto e: dna)
            val=val*4+GetIndex(e);
        myhash[val].fi++;myhash[val].se=i;
        int m=0x000fffff;
        for(int i=1;i+9<n;i++)
        {
            val<<=2;
            val&=m;
            val+=GetIndex(s[i+9]);
            myhash[val].fi++;myhash[val].se=i;
        }
        vector<string> ans;
        for(auto e: myhash)
        {
            if(e.se.fi>1) ans.push_back(s.substr(e.se.se, 10));
        }
        return ans;
    }
};

优化之后，我的代码在飞~

今天一个朋友问到一道概率题，我已经很生疏了。
2012年5月，10000个乘客里面在美联航出现延误航班的人数是0.81

问后面的10000人里面，有0个，至少一个和至少两个延误航班的概率。

一开始直接以为是二项分布，事件发生概率是0.81/10000, 然后二项分布搞搞，
但是答案是在Possion分布里面，主要是因为里面有2012年5月这个时间段里，给定的10000个人里面。

搜到著名博主ruanyifeng的一篇博客，
http://www.ruanyifeng.com/blog/2013/01/poisson_distribution.html
里面提到了泊松分布的三个条件
（1）顾客购买水果罐头是小概率事件。
（2）购买水果罐头的顾客是独立的，不会互相影响。
（3）顾客购买水果罐头的概率是稳定的。

但是感觉最重要的单位时间或者单位面积没有提及。

那么上面的题目lamda就是0.81， 带入公式即可

另外这道题目 似乎第二问没看懂 promoter是谁

Darwin Head, a 35-year-old sawmill worker, won
$1 million and a Chevrolet Malibu Hybrid by scoring

15 goals within 24 seconds at the Vancouver Canucks
National Hockey League game (B. Ziemer, “Darwin evolves
into an Instant Millionaire,” Vancouver Sun, February 28,
2008, p. 1). Head said he would use the money to pay off
his mortgage and provide for his children, and he had no
plans to quit his job. The contest was part of the Chevrolet
Malibu Million Dollar Shootout, sponsored by General
Motors Canadian Division. Did GM-Canada risk the
$1 million? No! GM-Canada purchased event insurance from
a company specializing in promotions at sporting events such
as a half-court basketball shot or a hole-in-one giveaway at
the local charity golf outing. The event insurance company
estimates the probability of a contestant winning the contest,
and for a modest charge, insures the event. The promoters pay
the insurance premium but take on no added risk as the in-
surance company will make the large payout in the unlikely
event that a contestant wins. To see how it works, suppose
that the insurance company estimates that the probability a
contestant would win a Million Dollar Shootout is 0.001, and
that the insurance company charges $4,000.
a. Calculate the expected value of the profit made by the
insurance company.
b. Many call this kind of situation a win–win opportunity
for the insurance company and the promoter. Do you
agree? explain.

题目出自 statics for managers using microsoft excel, 感觉国外教材的题目和国内教材风格不同。

Posted by richard爱闹 - 4月 28 2015
如需转载，请注明： 本文来自 Richard

DOS下查看一个文件内容，
more +3 file
表示查看前3行，对于查看大文件的前面几行比较有用

mmc.exe是Microsoft控制台程序，不会随Windows自动启动
25上占了12GB

今天尝试远程安装软件，还是识别为了本地安装

莙 jun
〔莙荙莱〕一年生或二年生草本植物，叶有长柄，可食。

http://www.cnblogs.com/tenghoo/p/3583764.html
登陆之后，可以越过”由于没有远程桌面授权服务器可以提供许可证，远程会话被中断。”, 登陆远程桌面

今天终于找回了一卡通的密码了。。。

今天看了一道概率题，二项分布一般是事件发生与不发生，然后每次实验之间是独立的，泊松分布一般是单位时间里的事件，例如单位时间内随机事件发生的次数的概率分布。如某一服务设施在一定时间内受到的服务请求的次数，电话交换机接到呼叫的次数、汽车站台的候客人数、机器出现的故障数、自然灾害发生的次数、DNA序列的变异数、放射性原子核的衰变数等等。

今天讨论到一个DNA序列里面考虑互补情况下的k-mer分析。

A=T,G=C，
k-mer个数是4^k个，由于互补配对，4^k/2个。

但是MetaCluster 3.0里面用到了一种非常奇怪的计算方法，当k为偶数的时候，
有信息量的k-mer(k=4)个数是136, (4^k/2+4^(k/2))/2.

具体是这样的，首先和之前的一样4^k/2种，其次就是他考虑了这种情况，

如果k-mer的互补的逆序等于它本身，那么需要单独算，例如ATAT，TATA这两个要单独算，不能算成一种，具体原因还有待考究。

也就是说k-mer前一半，k/2-mer里面要单独加，4^(k/2)

因此总的是(4^k+4^(k/2))/2种有信息量的k-mer

66棋盘里面，4个互不攻击的车的方案数：
C(6,4)C(6,4)*A(4,4)=5400
http://blog.csdn.net/lingzhm/article/details/44873881

Fibonacii数的应用：

兔子生育问题，初始有一对兔子，每一对刚出生的兔子要长一个月才可以成熟，然后可以生育一对小兔子。

现在初始有一对小兔子，1个月后(1时刻)，成熟然后生育一对小兔子，

Posted by richard爱闹 - 4月 18 2015
如需转载，请注明： 本文来自 Richard

unravel: 解开
cohort: 所有
dilution: 稀释
ligation： 绑
contamination: 污染物
faecal: 排泄物
trim: 修剪，剪枝
agglomerative: 成块的
homogenous: 同质的
heterogenous: 多样的
undergo: 经历
protocol: 计划
aberrant: 异常的
concomitant: 伴随的
speculate: 推测
skew: 歪斜的
inherent: 固有的

markdown 乘号用\*

http://codeforces.com/contest/526/problem/C

输入w, w1, w2, v1, v2

求max(n1*v1+n2*v2)
st. w1*n1+w2*n2<=w, n1,n2=0,1,2…,

看起来是个简单的线性规划，但是用程序实现是有技巧的。

今天看了卓大神学弟的博客之后，完全理解了这题如何利用数学进行优化时间复杂度从O(W)到O(sqrt(W))
http://mycodebattle.com/2015/04/codeforces-526c/

首先保证w1,v1是性价比更高的包，
if(v1/w1<v2/w2) swap(1,2)

if(w1>=sqrt(C)), 则w/w1<=sqrt(C), 那么直接包1，枚举就好了，时间复杂度O(sqrt(C))

否则，选择包2进行枚举，i=1->min(w/w2, w1-1)

至于第二个条件i=1->min(w/w2, w1-1)的证明如下：
首先如果可以装w1个包2，那么币可以装w2个包1，因为总重量相等，w1*w2=w2*w1
因为保证了v1/w1>=v2/w2, v1w2>=v2w1, 如果选了w1个包2的话，那么全部换成w2个包1，重量不变，并且价值相等或增加，因此包2如果选的>=w1，
则存在有一个至少等值的解，其包2的个数<w1

int a[maxn], n, t, m;
int main()
{
/*
#ifndef ONLINE_JUDGE
    freopen ("in.txt" , "r" , stdin);
    freopen ("out.txt" , "w" , stdout);
#endif
*/
    LL w, hr , hb, wr, wb;
    while(cin>>w)
    {
        cin>>hr>>hb>>wr>>wb;
        //if(double(hr)/wr<double(hb)/wb)

        if(double(hr)/wr<double(hb)/wb) swap(hr, hb), swap(wr, wb);
        LL maxv=0;
        //int qw=sqrt(w)
        if(wr*wr>w)
        {
            for(LL i=0;i<=w/wr;i++)
            {
                maxv=max(maxv, i*hr+(w-i*wr)/wb*hb);
            }
        }
        else
        {
            for(LL i=0;i<=min(w/wb,wr-1);i++)
            {
                maxv=max(maxv, i*hb+(w-i*wb)/wr*hr);
            }
        }
        cout<<maxv<<endl;
    }
    return 0;
}

Posted by richard爱闹 - 4月 15 2015
如需转载，请注明： 本文来自 Richard

当时比赛想了二分，二分没用在刀刃上。我只对前缀和和tm的比较做了二分，而没有加t>=a+(mid-1)b 这个条件二分

当时二分了一个位置，然后从这里往后遍历到L来找maxR, 结果算法是错的。

适合做知道二分，但是写个bug free的 代码，不适合做应用

c1=t>=a+(mid-1)b, c2=sum[mid]-sum[L-1]<=tm,
这道题目， if(c1 && c2)l=mid else r=mid-1,

这种一开始写只从len=3开始规约，len=3->1,2, len=2->2,-1

结果发现有一个错了，后来发现len=4->1,3, 因此外部长度判断应该放到while(len>=1), 这里先入为主是因为看了kuangbin的代码影响。

所以规约应该最多要考虑到len=4在某些情况下例如此处。

附上代码：

LL sum[maxn];
int main()
{

#ifndef ONLINE_JUDGE
    //freopen ("in.txt" , "r" , stdin);
    //freopen ("out.txt" , "w" , stdout);
#endif

    LL a, b, n, l, t, m, L;
    while(cin>>a>>b>>n)
    {
        sum[0]=0;//sumi: A+...+A+(i-1)B
        for(int i=1;i<=maxn;i++) sum[i]=sum[i-1]+a+(i-1)*b;
        for(int i=0;i<n;i++)
        {
            cin>>L>>t>>m;
            int l=L,r=maxn;
            int ans=-1;
            while(l<=r)
            {
                if(l+1==r || l==r)
                {
                    //cout<<"l r:"<<l<<" "<<r<<endl;
                    if(t>=a+(r-1)*b && sum[r]-sum[L-1]<=t*m) ans=r;
                    else if(t>=a+(l-1)*b && sum[l]-sum[L-1]<=t*m) ans=l;
                    break;
                }
                int mid=(l+r)/2;
                if(t>=a+(mid-1)*b && sum[mid]-sum[L-1]<=t*m) l=mid;
                else r=mid-1;
            }
            cout<<ans<<endl;
        }
    }
    return 0;
}

Posted by richard爱闹 - 4月 15 2015
如需转载，请注明： 本文来自 Richard