今天又发现了之前犯错，VS2010如果申请大内存，需要修改编译选项，X64,然后release进行编译优化。这样才能申请大空间，利用64位系统。记得之前G神说过，跑
8000k序列的时候遇到过

近期装了一下 Mac Windows双系统。

Mac文件系统是一个 Mac扩展板啥的，基于Unix，

插入光盘，然后启动按option键，一定要长按，然后出来启动选项，选择光盘，然后格一下盘。之前Windows系统，一定要格掉才能装Mac，变为一个文件卷。

重装Mac不难，然后装Win(顺序基本上不能换，估计)，利用Mac自带的bootcamp来做，分一半盘做Win，MacPro 15寸，500GB硬盘。

然后启动。由于2011年以前的MBP不能用U盘启动，可能是这个原因，我没法U盘装Win，因此刻盘Win旗舰版，然后还网上找了一个激活工具。lehu下的
Oem7F7_XiaZaiBa

Win系统是

cn_windows_7_ultimate_with_sp1_x64_dvd_u_677408.iso
，具体忘了哪里下的。配合可以激活。

然后安装Mac版的PS AI，以及Win的PS AI。Win的版是FUDANPT下的，ps cs5,
photoshopCS5
是这个绿色版，不用安装，直接用。

Win的AI是用自带的注册机生成一个激活码弄的。AI是这个
Adobe Illustrator CS4
，里面是自动机，安装选试用，后面不用。

然后激活Mac的PS，AI，AI是CC版，因此之前用CS版的amtlib.framework是不行的，blog.cavyff.com/archives/165,直接替换就可以了

AI的激活博客在这里 blog.cavyff.com/archives/996

ai版是CC，因此用CC对应的amtlib.framework

Illustrator_17_LS20.dmg CC版
Photoshop_12_LS3.dmg CS5

MBP又一次黑屏，又一次系统进不去，然后再进去修复磁盘然后又没修复，果然这个功能很鸡肋、

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

25服务器出现的问题 http://blog.csdn.net/testcs_dn/article/details/8674135

目前可能是由于 KMS无法激活导致的，然后正在收集数据一直等待，也没办法删除远程服务角色，因此25现在还是 无法远程连接

python xrange 和 range区别：
xrange 不生成list 效率高，
range效率低

如果for里面 需要访问整个序列，则必须range, 否则xrange提高效率

C++ 强制类型转换，如果变换类型，例如char -> int, 那么要用reinterprete_cast, 例如char*

char* p;
int* p=reinterpret_cast<int*>(p);

static_cast则不行

另外关于结构体占用字节数，可以有按照4字节对齐，以及按照1字节对齐两种

http://tehsausage.com/mingw-to-string 这个目录指出了MinGW GCC的 问题所在，to_string的问题，但是按照里面patch替换原来的库，发现还是没有解决问题

暂时还是添加了这个函数来实现

#include<sstream>
template <typename T>
std::string to_string(T value)
{
  //create an output string stream
  std::ostringstream os ;

  //throw the value into the string stream
  os << value ;

  //convert the string stream into a string and return
  return os.str() ;
}

今天学弟问到CB怎么添加第三方库的目录，找到解决方案

http://bbs.csdn.net/topics/330085695

project — build options — search directory —- compiler 自行添加一个相对或者绝对路径就好了

Eigen是一个C++版的数学库
http://eigen.tuxfamily.org/index.php?title=Main_Page

Richael Zhang
http://blog.csdn.net/abcjennifer/article/details/7781936

的测试代码

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

再次重申，算法经常涉及的是递推与递归，而不是公式，典型的DP，我之前写正则那题的时候，总会想着往前扫描前面所有的状态，
其实只需要看前面一个状态就可以了，这点是通过最优子结构性质保证的！

这道题目和LC上用L[] R[]数组的题目一样，都是维护两个数组，然后max(ans, L[i-1]+R[i+1]+1) if(a[i-1]+1<a[i+1])

递推关系也通过模拟出来了，发现找一组数据模拟一下运行是生成算法的利器！

但是一个致命点漏掉了，如果前后元素相差不满足2的话，还是需要更新的，max(ans, L[i-1]+1， R[i+1]+1)这点在第一遍的时候错了！

while(cin>>n)
{
    for(int i=0;i<n;i++) cin>>a[i];
    l[0]=1;
    for(int i=1;i<n;i++)
    {
        if(a[i]>a[i-1]) l[i]=l[i-1]+1;
        else l[i]=1;
    }
    r[n-1]=1;
    for(int i=n-2;i>=0;i--)
    {
        if(a[i]<a[i+1]) r[i]=r[i+1]+1;
        else r[i]=1;
    }
    int ans=1;
    for(int i=0;i<n;i++)
    {
        if(i-1>=0 && i+1<n)
        {
            if(a[i-1]+1<a[i+1]) ans=max(ans, l[i-1]+r[i+1]+1);
            else
                ans=max(ans, max(l[i-1]+1,r[i+1]+1));
        }
        else if(i-1>=0 && i+1>=n) ans=max(ans, l[i-1]+1);
        else if(i+1<n && i-1<0) ans=max(ans, r[i+1]+1);
    }
    cout<<ans<<endl;
}

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

这道题目想了很久才想到一个迭代的贪心，因为是满二叉树，所以顺序存储是比较简便的。

先往上面填，因为下面先填的话很多分支都要填，值就要变大。关键是当时没有想到怎么分治的算，于是写了一个迭代的算法。

void Solve_Iterative()
{
    for(int i=(tn-1)/2+1;i<=tn;i++) b[i]=0;
    for(int i=(tn-1)/2;i>=0;i--)
    {
        b[i]=max(a[2*i+1]+b[2*i+1], a[2*i+2]+b[2*i+2]);
    }
    //cout<<tn<<endl;
    //for(int i=0;i<=(tn-1)/2;i++) cout<<b[i]<<" ";
    int cnt=0;
    for(int i=1;i<=tn;i++)
    {
        cnt+=b[(i-1)/2]-b[i]-a[i];
    }
    cout<<cnt<<endl;
}

后来看了DuYuhao的代码，其实是累加两颗子树的最大路径的差值，其实完全可以分治的算路径，而结果是全局变量累加起来的。显然
分治算法直观而且快速，编程复杂度低很低，DuYuhao大神(TooSimple)也是几分钟就A了

int dfs(int i)
{
    if(i>=(1<<n)) return 0;
    int l=dfs(2*i)+a[2*i], r=dfs(2*i+1)+a[2*i+1];
    ans+=abs(l-r);
    return max(l, r);
}

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

数据支撑这个观点
the claim is backed with data

crank: 上下摆动！
programming contest winners are used to cranking solutions out fast
and that you performed better at the job if you were more reflective and went slowly and made sure things were right

hit the nail on the head
一针见血

今天遇到了一个 GCC编译需要动态链接库的问题，DLL，按道理设置静态链接就好了，如果本地有dll的话，
改成-static静态链接，也就是编译时直接链接到exe，这样不同机器都可以跑，但是却没有按照预期。

推荐一个数学题，偏数论题的网站，小胖发给我的。
https://projecteuler.net/problem=1

第一题和14年微软校招笔试第一题一样，beautiful string, 最好的方法就是编码 大法。但是我比赛的时候由于紧张，没有想到这个方法，导致改了很多次，浪费了时间。

最后写的是这个版本

while(cin>>str)
{
    int i, n=str.size();bool ok=1;
    for(i=1;str[i]==str[0] && i<n;i++);
    if(i*3==n)
    {
        if(!(str[0]!=str[i] && str[0]!=str[2*i] && str[i]!=str[2*i])) {puts("NO");continue;}
        string s2(i, str[i]);
        string s3(i, str[2*i]);
        if(s2!=str.substr(i, i) || s3!=str.substr(2*i, i)) {puts("NO");continue;}
        puts("YES");
    }
    else puts("NO");
}

瞿神指导的编码大法应该来说是最简洁安全的

while(cin>>str)
{
    v.clear();
    int cnt=0;n=str.size();
    for(int i=0;i<n;i++)
    {
        if(i && str[i]!=str[i-1])
        {
            v.push_back({str[i-1], cnt});
            cnt=1;
        }
        else cnt++;
    }
    v.push_back({str[n-1],cnt});
    cout<<v.size()<<" "<<v[0].cnt<<" "<<v[1].cnt<<" "<<v[2].cnt<<endl;
    if(v.size()==3 && v[0].cnt==v[1].cnt && v[1].cnt==v[2].cnt &&
       v[0].c!=v[1].c && v[0].c!=v[2].c && v[1].c!=v[2].c)
        puts("YES");
    else puts("NO");
}

第二题没啥算法，直接map就好了，数据结构题，掐输入这种其实对面试没啥帮助

CF第一题虽然复杂度写高了，但是不影响结果。第二题是一道思维题，一开始没有想清楚，就写。一定拿个一般的例子走一遍，确定无误了，再写。
其实就是算每颗子树的最长路径，从下往上递推，然后再从上往下算差值。

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

今天眼睛抱恙了，看的非常累，不是平常的那种疲惫，而是略带痛的感觉。但是问题不大。

看了算法书上最优服务次序问题，记得当时算法课上，沈云付说过这是一个结论不等式，具体名字忘了，

对于a1…an, b1…bn， 则sum(i=1->n)ai*bi 里面一个递增，一个递减排列是所有排列里面最小的。

具体证明如下：假设当前已经是最优排列(a1b2…bn)，若交换b1 b2

则(a2b1+a1b2)-(a1b1+a2b2)=(b1-b2)(a2-a1)>0,因此交换之后都是变大的。记得一次在食堂炒肉大神口述了一下这个过程
重要的是，这个结论不仅用于正数，而且用于负数

用于ECNU一道向量点积最小题，还有这道最优服务次序，本质是min((n-1)a1+….an-1), 因此a[]递增排列是最小的。

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

== 是裸地 直接比较两个变量值是否相同，例如两个对象，存放的是地址值，则比较地址值是否相同，也即是否指向同一对象
.Equals() 方法是比较两个对象指向的地址空间内容是否相同。

经常犯的错误就是两个字符串对象，经常用==比较内容

其实正确做法是用Equals比较内容

String a=new String(“foo”);
String b=new String(“foo”);
比较两个字符串内容是否相同，用Equals方法。而C++

string a(“abc”), b(“abc”), 则直接用a==b 就可以比较字符串内容，没有Equals这种问题，是因为有一个函数专门转化为比较字符串内容是否相同了。

而java可能没有做这一点，因此需要用Equals来比较。

其实cpp string也是一样，比较== comapre相当于 == Equals分别比较地址值和字符串内容，只是==处理两个字符串对象的时候，会自动比较内容。但是不是成员函数。
并且string一般不用new，也不用指针，因此比较好做。

cpp string == 有一个顺序关系，他会自动调用==
http://www.cplusplus.com/reference/string/string/operators/

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

听着稻香，充满着正能量！

记住“a mod b”是a除以b的余数；34 mod 10等于4，一般而言，当其中的a是负数时，不论b的符号如何结果都是负数，但是在数学计算中却不是这样，需要谨记！

再次总结dfs，框架是这样的：

bool dfs(int i, int j)
{
    if(outrange || visited) return 0;
    if(search a solution) return 1;
    visited i, j;
    for()
    {
        extend to next level;
        if(dfs()) return 1;
    }
    no visited i,j
    return 0;
}

最好是先判终止条件，或者叫剪枝，然后再看解。

Wordsearch 这题有点特殊，因为先判终止条件要访问word，因此有下标，因此正好前面判断是否越界，于是找到解放到前面了

找一条骑士周游路线

bool dfs(int i, int j, int cnt)
{
    if(out(i, j) || v[i][j]) return 0;
    if(cnt==n*m) return 1;
    v[i][j]=1;
    for(int k=0;k<8;k++)
    {
        int ni=i+dx[k], nj=j+dy[k];
        cur.push_back({ni, nj});
        if(dfs(ni, nj, cnt+1)) return 1;
        cur.pop_back();
    }
    v[i][j]=0;
    return 0;
}

word search 写成这种的可能会刚好找不到出口，其实是有解的

bool dfs(int curi, int curj, int wi)
{
    if(out(curi, curj) || v[curi][curj] || wi<word_.size() && b[curi][curj]!=word_[wi]) return 0;
    if(wi==word_.size()) return 1;
    v[curi][curj]=1;
    for(int k=0;k<4;k++)
    {
        int nx=curi+dx[k], ny=curj+dy[k];
        if(dfs(nx, ny, wi+1)) return 1;
    }
    v[curi][curj]=0;
    return 0;
}

所以还是这样写

bool dfs(int curi, int curj, int wi)
{
    if(wi==word_.size()) return 1;
    if(out(curi, curj) || v[curi][curj] || b[curi][curj]!=word_[wi]) return 0;
    v[curi][curj]=1;
    for(int k=0;k<4;k++)
    {
        int nx=curi+dx[k], ny=curj+dy[k];
        if(dfs(nx, ny, wi+1)) return 1;
    }
    v[curi][curj]=0;
    return 0;
}

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

对于表格建立 B树索引和hash索引

多个字段建立B树索引，相对于对每个字段分别建立B树索引，因为如果直接一颗B树，比较不好做，可能是2^n颗子树， 而hash索引则是一系列字段组合
计算hash函数。

因此如果在ABC上建立hash索引，查询只能where A=’a’ && B=’b’ && C=’c’
但是如果建立B树索引，则查询可以是三个字段的8种组合查询，功能更强大些。

atoi 函数说明文档：

The function first discards as many whitespace characters as necessary until the first non-whitespace character is found.
Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible,
and interprets them as a numerical value.

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

bitmask 诸位check 位运算搞笑，不要除2坐，除2就是右移
for(int j=0;j<n;j++)
{
int k=(1<<j)&i;
}

decimated 大幅下降
decimal 十进制
by virtual of 由于
designate 指派 assign
今天重新看了一下SKWIC算法，经过蛋哥的梳理，现在完全看懂了算法的流程。

delta_i其实就是目标函数的 左边类内距离之和 和 右侧的惩罚项对于vik的函数是同一阶的。然后算出deltai, 并进行解释为什么要这么设置delta_i

今天回顾了一下在廖瑞琪师兄，易源师兄里面都用到了的SKWIC算法，其实文章里有一个deltai的公式就xifeng一下就出来了，一直值得遐想。

不过那个公式先暂放，里面还有非常多不严谨的地方。

Kmeans算法的Minimize公式是虽有类内距离之和最小化，现在是一个自动加权的机制，也就是两个样本之间的欧氏距离，比如，是每一维差的平方和，
这个和是等权值的和，理解成权值都是1。

现在基于这一一个目的，对每一维赋予一个权值，更具体的，对于每一个cluster的每一维特征，都赋予一个权值，并且是自动加权的，初始值显然1/n比较合适。

目标函数是右边加了一串东西，具体的见 鄙人主页里，这个博客系统打复杂公式还不熟练 http://admis.fudan.edu.cn/~rczhang/rczhang_academic/GIW2013.pdf

然后对于含约束条件的极值问题，采用拉格朗日乘子，高数一比较做的多是单变量，现在是C个变量，C是Cluster数量，准确的说是C*n个变量，n是维度，但是我们
进行矩阵或者向量的推导时，看成C个向量，因此还是C各变量，用C个lamda变量构造拉格朗日函数。

然后对Vik和lamdai分别求导，这里对向量求导需要习惯。然后计算Vik，这个是权值矩阵。

通过两个式子计算Vik，里面有一个deltai这个初始值是选了一个较小的值，例如0.001，文章中对这点没有提及，是疏漏之一。

然后updata 类中心向量的时候也有一些区别，对于Vik=0，表示第k维特征与第i个类无关，那么直接对于这一维的类中心分量为0，而其他则按照普通的平均公式计算类中心。

SKWIC算法流程：
初始：vik=1/n，类中心随机抽取

Repeat
    算Vik，权值矩阵C*n
    算DWCij，距离矩阵C*N，按照对应距离公式计算
    归类，按照距离最近原则
    Cik，Vik=0的赋值0，其他按照普通均值向量计算
    算dealtai，公式没有来头
Until

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