<![CDATA[AllenYick's blog]]> 2016-03-08T14:13:24.754Z http://allenyick.com/ Hexo <![CDATA[C++面向对象]]> http://allenyick.com/2016/03/08/C-面向对象/ 2016-03-08T12:36:07.000Z 2016-03-08T14:13:24.754Z 概述

面向对象编程基于三个基本概念：数据抽象、继承和动态绑定。在C++中，用类进行数据抽象，用类派生从一个类继承基类的成员。动态绑定使编译器能够在运行时决定是使用基类中定义的函数还是派生类中定义的函数。
继承和动态绑定在两个方面简化了程序：

  1. 能够容易地定义与其他类相似但又不同的新类；
  2. 能都更容易地忽略这些相似类型之间区别的程序。

继承

通过继承可以实现类型之间的建模，共享公共的东西，仅仅特化本质上不同的东西。派生类可以继承基类定义的成员，派生类可以无需改变而使用那些与派生类型具有特性不相关的操作，派生类可以重定义那些与派生类相关的成员函数，将函数特化，考虑派生类型的特性。派生类还可以定义更多的成员。

定义基类

// C++ primer中的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Class Item_base {
public:
    Item_base(const std::string & book = "", double sales_price = 0.0) :
        isbn(book), price(sales_price) { }
    std::string book() const { return isbn; }
    // reutrn total sales price for a specified number of items
    // derived classes will override and apply different discount algorithm
    virtual double net_price(std::size_t n) const
        { return n * price; }
    virtual ~Item_base() { }
private:
    std::string isbn;  // identifier for the iterm
protected:
    double price;      // nomal, undiscounted price
}

Item_base定义了两个成员函数，一个带有保留字virtual。目的是启用动态绑定。成员默认为非虚函数，引入了protected访问标号，具体在以下介绍。

访问控制

public与private具有普通含义，public: 可以被类的用户和类的成员访问也可以被类的派生类访问（除私有派生），private：可以被类的成员访问但不能被类的用户和派生类访问。引入protectd，是public与private的混合：

  • 像private一样，不能被类的用户访问；
  • 像public一样，可被类的派生类访问。
    另外，派生类只能通过派生类对象访问其基类的protected成员，但不能访问其基类对象的protected成员。

定义派生类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// discount kicks in when a specified number of copies of same book are sold
// the discount is expresses as a fraction used reduce the normal price
class Bulk_item : public Item_base {
public:
    // redefines base version so as to implement bulk purchaes discount policy
    double net_price(std::size_t) const;
private:
    std::size_t min_qty;   // minimum purchaes for discount to apply
    double discount;       // fractional discount to apply
}
double Bulk_item::net_price(std::size_t cnt) const
{
    if(cnt >= min_qty)
        return cnt * (1 - discount) * price;
    else 
        return cnt * price;
}

每个Bulk_item对象包含四个数据成员：从Item_base继承的两个isbn和price，自己定义的两个min_qty和discount。并重写了net_price()函数。

动态绑定

C++函数调用默认不使用动态绑定，要触发动态绑定，必须满足两个条件：

  1. 只有指定为虚函数的成员函数才能进行动态绑定；
  2. 必须通过基类类型的引用或指针进行函数调用；

基类类型引用和指针的关键点在于静态类型（在编译时可知的引用类型或指针类型）和动态类型（指针或引用所绑定的对象的类型，这是仅在运行时可知的）可能不同。

通过基类引用或指针调用基类中定义的函数时，我们并不知道执行函数的对象的确切类型，执行函数的对象可能是基类类型的，也可能是派生类型的。如果调用非虚函数，则无论实际对象是什么类型，都执行基类类型定义的函数。因此在编译是就确定了非虚函数的调用。

]]> 概述

面向对象编程基于三个基本概念：数据抽象、继承和动态绑定。在C++中，用类进行数据抽象，用类派生从一个类继承基类的成员。动态绑定使编译器能够在运行时决定是使用基类中定义的函数还是派生类中定义的函数。
继承和动态绑定在两个方面简化了程序：

  1. 能够容易地定义与其他类相似但又不同的新类；
  2. 能都更容易地忽略这些相似类型之间区别的程序。

继承

通过继承可以实现类型之间的建模，共享公共的东西，仅仅特化本质上不同的东西。派生类可以继承基类定义的成员，派生类可以无需改变而使用那些与派生类型具有特性不相关的操作，派生类可以重定义那些与派生类相关的成员函数，将函数特化，考虑派生类型的特性。派生类还可以定义更多的成员。
]]>

<![CDATA[最小二乘学习法]]> http://allenyick.com/2015/12/18/最小二乘学习法/ 2015-12-18T12:42:49.000Z 2015-12-22T06:44:31.992Z 最小二乘学习法是回归中最为基础的方法。

我们以$d$维实向量$\boldsymbol{x}$作为输入、以实数值$y$作为输出的函数$y=f(x)$的学习问题进行说明。这里的真实函数关系$f$是未知的，通过训练样本$\{({x_i}, y_i)\}_{i=1}^{n}$对其进行学习，一般情况下，输出样本$y_i$的真实值$f(x_i)$中经常会观测到噪声。

最小二乘学习法推导

最小二乘学习法是对模型的输出$f_\theta(x_i)$和训练集输出$\{ y_i\}_{i=1}^{n}$的平均误差


$J_{LS}(\boldsymbol{\theta})=\frac{1}{2}\sum\limits_{i=1}^{n}(f_\theta(x_i)-y_i)^2 \qquad (1.1)$

为最小时的参数$\theta$进行学习。

$\widehat{\boldsymbol{\theta}}_{LS}=\mathop{argmin}_{\theta}J_{LS}(\boldsymbol{\theta})$

“LS”是Least Square的首字母。式(1.1)中加上系数1/2，是为了约去对$J_{LS}$微分时得到的2。平方误差$(f_\theta(x_i)-y_i)^2$是残差$f_\theta(x_i)-y_i$的$l_2$范数。因此最小二乘法有时也称为$l_2$损失最小法。

如果使用线性模型

$f_\theta(\boldsymbol{x})=\sum\limits_{j=1}^{b} \theta_i\phi_i(\boldsymbol{x})=\boldsymbol{\theta}^{T}\phi(\boldsymbol{x})$

的话，训练样本的平方差$J_{LS}$就能够表示为下述形式

$J_{LS}(\boldsymbol{\theta})=\frac{1}{2}\lVert\Phi\boldsymbol{\theta}-\boldsymbol{y}\rVert^2$

在这里，$\boldsymbol{y}=(y_1, \ldots,y_n)^T$是训练输出的$n$维向量，$\Phi$是下式中定义的$n{\times}b$阶矩阵，也称为设计矩阵。

$$\Phi= \begin{pmatrix} \phi_1(\boldsymbol{x}_1) & \ldots & \phi_b(\boldsymbol{x}_1)\\ \vdots & \ddots & \vdots \\ \phi_1(\boldsymbol{x}_n) & \ldots & \phi_b(\boldsymbol{x}_n)\\ \end{pmatrix}$$

平方误差$J_{LS}$关于参数向量$\boldsymbol{\theta}$的导数为

$\nabla_{\theta}J_{LS}=(\frac{\partial J_{LS} }{\partial {\theta}_1}, \ldots, \frac{\partial J_{LS} }{\partial {\theta}_b} )^T=\Phi^T\Phi\boldsymbol{\theta}-\Phi^T\boldsymbol{y}$

令上式为零，得到

$\Phi^T\Phi\boldsymbol{\theta}=\Phi^T{y}$

解$\widehat{\boldsymbol{\theta}}_{LS}$可以表示为

$\widehat{\boldsymbol{\theta}}_{LS}=\Phi^\dagger{y}$

$\Phi^T\Phi$有逆矩阵的时候，广义逆矩阵$\Phi^\dagger$可以用下式表示：

$\Phi^\dagger=(\Phi^T\Phi)^{-1}\Phi^T$

最小二乘法的应用

]]> <![CDATA[Count of Smaller Numbers After Self]]> http://allenyick.com/2015/12/16/Count-of-Smaller-Numbers-After-Self/ 2015-12-16T09:25:42.000Z 2016-01-13T06:53:11.047Z 题目描述

在一个整数序列中，统计每个元素其右边的元素中比本身小的元素个数，并返回。题目来源leetcode。

本题需要注意两点：元素均为整数，元素可能重复。

例子:

给定 nums = [5, 2, 6, 1]

  • 5右边有两个更小的数 (2 , 1).
  • 2右边有两个更小的数(1).
  • 6右边有两个更小的数(1).
  • 最右边的数没有比它小的数.

返回序列 count = [2, 1, 1, 0]。

思路

自右向左处理每一个数，我们知道对于每一个数，只要遍历它右边的每个数，再与本身做一个比较不就知道答案了吗？这样的算法不难想到，也容易实现，时间复杂度为O(n^2)。

这样的处理方法，对每个数的处理跟以前的都没有关系，比如这样的一个例子：

[7, 4, 5, 6, 2, 9, 8, 4, 7]

在处理9的时候，其实比9小的数就是9后边一个8对应的count加上8的个数。如果有这些信息我们很快就能得到9对应的count值。

在知道了处理的过程中是有信息可以利用的以后，在处理每个数的时候可以将复杂度降到O(logn)甚至O(k)，现在主要的任务是寻找一个适当的算法或数据结构。跟大小有关的数据结构我们知道有二叉搜索树，对每一个结点，左子树的值总是大于该结点的值，右子树的值总是小于该结点的值，左子树和右子树都是一棵二叉搜索树。

这样在处理的时候，实际上是在维护一棵二叉搜索树，二叉树每个结点，的数据结构和示意图如下：

1
2
3
4
5
6
7
8
struct BinarySearchTreeNode
{
    int val;      // 数值
    int less;     // 比val小的数个数
    int count;    // 值为val的个数
    BinarySearchTreeNode *left, *right;
    BinarySearchTreeNode(int value) : val(value), less(0),count(1),left(NULL), right(NULL) {}
};

node

对上边的例子：

  1. 首先添加7作为根结点

  2. 对每一个数，ans初始化为0用来保存结果，从树根节点往下搜索，

    • 当该数小于结点对应的数时，往右子树向下递归搜索，该结点的less加1
    • 当该数大于结点对应的数时，往左子树向下递归搜索，ans加上该结点的count和less
    • 当该数等于结点对应的数时，该结点的count加1，ans加上该结点的count
    • 保存ans

  3. 返回ans每个数对应的ans

处理的过程伪代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// root为树的根结点
// node为一个结点
// ans表示最后的结果
insert(root, node, ans)
    If node.value < root.value
        root.less = root.less+1
        If root.right is NULL
            root.right <- node
            return
        End If
        insert(root.right, node, ans)
    Else If node.value > root.value
        ans =  ans + root.less + root.count
        If root.left is NULL
            root.left <- node
            return
        End If
        insert(root.left, node, ans)
    Else node.value == root.value
        root.count = root.count + 1
        ans = ans + root.less
    End If

代码 Cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
// bianry search tree
struct BinarySearchTreeNode
{
    int val;
    int less;
    int count;
    BinarySearchTreeNode *left, *right;
    BinarySearchTreeNode(int value) : val(value), less(0),count(1),left(NULL), right(NULL) {}
};

void insert(BinarySearchTreeNode *root, const int value, int &numLessThan)
{
    if(value < root->val)  // right
    {
        root->less++;
        if(root->right == NULL)
            root->right = new BinarySearchTreeNode(value);
        else
            insert(root->right, value, numLessThan);
    }
    else if(value > root->val)
    {
        numLessThan += root->less + root->count;
        if(!root->left)
            root->left = new BinarySearchTreeNode(value);
        else
            insert(root->left, value, numLessThan);
    }
    else
    {
        numLessThan += root->less;
        root->count++;
    }
}

vector<int> countSmaller(vector<int>& nums) {
    vector<int> count(nums.size());
    if(nums.size() == 0)
        return count;
    BinarySearchTreeNode root(nums[nums.size()-1]);
    for(int i = nums.size() - 2; i >= 0; i--)
    {
        int numLessThan = 0;
        insert(&root, nums[i], numLessThan);
        count[i] = numLessThan;
    }
    return count;
}

// int arr[] = {7, 4, 5, 6, 2, 9, 8, 4, 7}
// vector<int> nums(begin(arr), end(arr));
// auto vec = countSmaller(nums);
// for(auto x : vex)
//    cout << x << " ";    

//  input:  [7, 4, 5, 6, 2, 9, 8, 4, 7]
//  output: [5, 1, 2, 2, 0, 3, 2, 0, 0]

运算过程

下面是该例子的处理过程中的示意图：

[8,4,7]

最后该二叉搜索树如下：

final binary search tree of [7, 4, 5, 6, 2, 9, 8, 4, 7]

总结

虽然该算法的平均复杂度还能达到O(logn)，但在最坏的情况下为O(n^2)。原因是二叉搜索树退化成了一个链表。比如一个非递减序列或一个非递增序列。

该方法还有其他的解法，诸如像segment-tree、binary-indexed-tree、divide-and-conquer等方法。

]]> 题目描述

在一个整数序列中，统计每个元素其右边的元素中比本身小的元素个数，并返回。题目来源leetcode。

本题需要注意两点：元素均为整数，元素可能重复。

例子:

给定 nums = [5, 2, 6, 1]

  • 5右边有两个更小的数 (2 , 1).
  • 2右边有两个更小的数(1).
  • 6右边有两个更小的数(1).
  • 最右边的数没有比它小的数.

返回序列 count = [2, 1, 1, 0]。
]]>

<![CDATA[Arithmetic Puzzles]]> http://allenyick.com/2015/12/03/Arithmetic-Puzzles/ 2015-12-03T06:36:15.000Z 2015-12-15T02:24:26.926Z Arithmetic Puzzles：给定一个由字母组成的等式，其中每一个字母表示一个数字。不同字母表示的数字一定不同。问字母和数字之间是否存在一一对应关系，使得等式成立。若存在多种方案输出按字母顺序排列后字典序最小的解。

比如 SEND+MORE=MONEY 的一个解为 9567+1085=10652。

题目的完整描述如下，来自hihocoder：

描述
Arithmetic puzzle is a type of mathematical game consisting of a mathematical equation among unknown numbers, whose digits are represented by letters. The goal is to identify the value of each letter. – wikipedia

For example, SEND+MORE=MONEY is a famous one of such puzzles. The solution is 9567+1085=10652. Note that different letters should represent different digits and the leading digit of a multi-digit number shoud not be zero.

Given an arithmetic puzzle, please find the solution.

输入
The first line contains an integer T(1 <= T <= 10), the number of puzzles.

N lines follow. Each line contains a puzzle. A puzzle consists of only ‘+’, ‘=’ and capital letters. The length of each puzzle will not exceed 100.

输出
For each puzzle output one line. If there is no solution output “No Solution” without qoutes, otherwise output the first solution by alphabetical order.

样例输入
4
A+B+C=AB
A+B+C=A+B
IOOOOOOOOOOOOOOOOOOOOOOOOO=IOOOOOOOOOOOOOOOOOOOOOOOOO
C=A
样例输出
1+0+9=10
1+2+0=1+2
10000000000000000000000000=10000000000000000000000000
No Solution

解题思路

根据题意我们可以得到下面几个条件：

  1. 最多只会有10个数字，所以解的组合数不超过 10!=3,628,800
  2. 最多允许存在10个字母，否则一定是No Solution
  3. 当单词长度超过1时，其首字母肯定不为0

一个简单的解法

首先我们需要将所有字母都找出来，按照字典序排列。再从第一个字母开始按字典序枚举数字，当给每一个字母分配了数字之后，将其带入等式，检查是否相等。

枚举数字时需要注意有的字母不能等于0，这一步我们可以在预处理中完成，用数组notZero表示该字母是否不能为0。

那么可以写出伪代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
dfs(letter):  // for every letter
    startNum = 0  // 从0开始枚举
    If (notZero[ letter ]) Then   // 不能为0，则从1开始
        startNum = 1
    End If
    For i = startNum ... 9
        If not useNum[i] Then     // 数字i未使用过
            useNum[i] = true
            val[ letter ] = i     // letter对应数字 i
            If letter is last letter Then   // 如果是最后一个letter
                If (check(val)) Then
                    Return True   // 得到一个解
                End If
            Else 
                If (dfs(next letter)) Then   // 枚举下一个letter
                    Return True
                End If
            End If
            // 重置i和letter的状态
            val[ letter ] = -1
            useNum[i] = false
        End If
    End For
    Return False

  • val表示每个字母对应的数字，初始化为-1

  • useNum表示已经使用了的数字，初始为为false

  • check(val)表示将现在的val带入原公式检查是否合法

由于等式长度最大为100，有可能出现两个长度为49的数字进行比较，显然无法正常的采用转化为整数再进行比较的方法。

对于这样的情况，我们有如下的解决方案：

首先将等式右边的单词全部移到左边，这样公式就变成了形如：

word1 + word2 + … + word4 - word5 - word6 - … - word8 = 0

举个例子：SEND+MORE-MONEY=0

将其写成笔算的形式

+  SEND
+  MORE
- MONEY
------------
            0

接下来我们从最低位开始，一位一位向高位进行计算。假设前一位的进位为w，则当前位的总和为当前位所有出现过的字母之和加上w。最低位时，因为肯定没有进位，所以w = 0。

每一位的和为：s = D + E - Y + w。

由于我们之前已经枚举出了所有字母表示的数字，因此我们可以直接得到这个和s。

由于我们要使得最后的结果为0，所以s的末尾一定需要为0。

因此判定合法的条件为s % 10 == 0。

若s满足末尾为0，则我们可以继续向高位计算，新的进位为w = s / 10。

当计算到最高位时，不能产生进位，还需要额外判断s = 0。

伪代码为：

1
2
3
4
5
6
7
8
9
10
11
12
13
check(val)
    w = 0
    For i = low order .. high order       // 从低位像高位计算
        s = sigma(digit at order i) + w   // val
        If (s % 10 != 0) Then
            Return False
        End If
        If (i == high order && s != 0) Then
            Return False
        End If
        w = s / 10   // 进位
    End For
    Return True

假设一共出现了m个字母，n种字母。则该算法枚举组合的时间复杂度为 O(10! / (10 - n)!) ~= O(10!)，检查是否合法的时间复杂度为 O(m)，总的时间复杂度为 O(10!*m)

对于给定的时间限制肯定是会TLE的，因此我们需要对其进行优化。

代码一

上述算法的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <ctime>
using namespace std;

string str;
vector<int> val(128, -1);        // 每个字母对应的数字， 默认-1
vector<bool> useNum(10, false);    // 是否使用过该数字
vector<bool> notZero(128, false);  // 是否可以为0，不能：true， 能：false
struct Word
{
    string num;
    int sign;   // 1:+, -1:-
}; 
vector<Word> words;
vector<char> letters;

// initialize variables
void init()
{
    words.clear();
    letters.clear();
    val.assign(128, -1);
    notZero.assign(128, false);
    useNum.assign(10, false);

    bool haveLetter[128] = {false};
    int flag = 1;   //+
    int sign = 1;
    int pre = 0, i = 0, n = str.size();
    for(; i < n; i++) 
    {
        char c = str[i];
        if(c == '+' || c == '-' || c == '=' ) 
        {
            words.push_back({str.substr(pre, i - pre), sign});
            if(c == '-')
                sign = -flag;
            else if(c == '=')
            {
                flag = -flag;
                sign = flag;
            }   
            if(i - pre > 1) 
                notZero[str[pre]] = true;
            pre = i + 1;
        }
        else
            haveLetter[c] = true;
    }
    words.push_back({str.substr(pre, n - pre), sign});
    for(int i = 0; i < words.size(); i++)
        reverse(words[i].num.begin(), words[i].num.end());
    if(n - pre > 1)
        notZero[str[pre]] = true;
    for(int c = 0; c < 128; c++)
        if(haveLetter[c])
            letters.push_back(c);
}

// check the value
bool checkVal()
{
    int w = 0, s = w;
    bool endFalg = false;
    int id = 0;
    while(!endFalg)
    {
        endFalg = true;
        s = w;
        for(auto word : words)
        {
            if( id < word.num.size() )
            {
                s += val[word.num[id]] * word.sign;
                endFalg = false;
            }
        }
        if(s % 10 != 0)
            return false;
        w = s / 10;
        id++;
    }
    return s == 0;
}

// display the result
void disp()
{
    for(auto c : str)
    {
        if( c != '+' && c != '-' && c != '=' )
            cout << val[c];
        else
            cout << c;
    }
    cout << endl;
}

// depth first search
bool dfs(int idx)
{
    char letter = letters[idx];
    int startNum = 0;
    if(notZero[letter])
        startNum = 1;
    for(int i = startNum; i <= 9; i++)
    {
        if( !useNum[i] )
        {
            useNum[i] = true;
            val[letter] = i;
            if(idx == letters.size() - 1)
            {
                if(checkVal())
                {
                    return true;
                }   
            }
            else
            {
                if(dfs(idx + 1))
                    return true;
            }
            useNum[i] = false;
            val[letter] = -1;
        }
    }
    return false;
}

int main()
{
    while(cin >> str)
    {
        clock_t t = clock();
        init();

        if( !dfs(0) )
            cout << "no solution\n";
        else
            disp();
        t = clock() - t;
        cout << "Elapse " << t  << " ms" << endl;
    }
    return 0;
}

对SEND+MORE=MONEY的运行时间为 780 ms。

优化一

在上面的算法中，我们是按照字母顺序以及字典序开始搜索。总是在枚举完全部的字母后，才进行匹配。然而实际上我们会遇到这样的情况：

比如DCBA+DCCA-DDDA=0，当我们枚举出A的值时，已经可以判定等式最后一位是否能够满足要求。但是在上面的算法中，我们并没有这么做，而是一直在枚举后面的字母。

因此我们提出一个改进的方法，我们按照从低位到高位的过程中，字母出现的顺序去枚举。这样做有一个好处和一个坏处：

好处是，能够在最短时间内检查出是否合法，而不需要去对整个等式进行检查。

坏处是，必须要枚举出所有可能的组合情况，并从中选取字典序最小的情况。

但实际上，由于该方法剪枝的强度比较大，所以对于大多数情况都能够很好的解决。除了一种特殊的情况，这个我们会在优化二中讲到。

该算法的实现要点：

  • 根据笔算公式
 + SEND
+ MORE
-MONEY

从右到左，从上到下，同时计算w和s的值。设最大的位数为m位，一共有n个单词。我们用(i,j)来表示当前枚举到了右起第i位，上起第j个字母。比如在上面例子中(1,1)就是右上角的D，(2,3)就是MONEY中的E。

  • 当枚举到的字母(i,j)尚未赋值时，枚举它可能出现的值；否则直接使用已经枚举的值。

  • 当j = n + 1 时，表示该位所有的字母都已经枚举完毕，此时计算 w 和 s 并根据结果，决定是否递归计算(i+1,1)。

  • 当i = m + 1时，表示所有位置都已经枚举完毕，此时根据进位的w是否等于0，来判定当前解是否合法。

伪代码实现为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
dfs(i, j, s):
    If (i == m + 1) Then    // 所有位置都枚举完
        If (s == 0) Then
            UpdateAns()
        End If
        Return 
    End If
    If (j == n + 1) Then    // 该位所有字母都已经枚举完
        If (s % 10 == 0) Then
            dfs(i + 1, 1, s / 10) // 直接将w加入s
        Else
            Return 
        End If
    End If
    letter = getLetter(i, j)   // 获得（i,j）处的字母
    If (val[ letter ] != -1) Then    // 该字母尚已赋值
        dfs(i, j + 1, s + val[ letter ] * op[j])
    Else
        startNum = 0
        If (notZero[ letter ]) Then 
            startNum = 1
        End If
        For i = startNum .. 9
            If not useNum[i] Then
                useNum[i] = true
                val[ letter ] = i
                dfs(i, j + 1, s + val[ letter ] * op[j])
                val[ letter ] = -1
                useNum[i] = false
            End If
        End If
    End If

优化一代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <ctime>
using namespace std;

class ArithmeticPuzzles
{
public:
    ArithmeticPuzzles(const string s);
    ~ArithmeticPuzzles(){};

    void init();                      // 对变量进行初始化
    void dfs(int i, int j, int s);    // 深度搜索
    void disp();                      // 显示结果
    char getLetter(int i, int j);     // 获得(i,j)处的字母
    void UpdateAns();                 // 更新结果/答案

private:
    string equation;
    std::vector<int> value;       // 每个字母对应的数字， 默认-1
    std::vector<bool> useNum;     // 是否使用过该数字
    std::vector<bool> notZero;    // 是否可以为0，不能：true， 能：false
    std::vector<string> nums;     // 以运算符分开的数字
    std::vector<int> operators;   // 运算符，与nums对应
    std::vector<char> letters;    // 出现的字母
    std::vector<int> result;      // 结果：保存字母对应的数字
    int n;              // 单词数量  
    int maxLength;      // 单词最大长度
    bool hasAnswer;     // 是否有解
};

ArithmeticPuzzles::ArithmeticPuzzles(string str) : equation(str)
{
    value.resize(128, -1);
    result.resize(128, -1);
    useNum.resize(10, false);
    notZero.resize(128, false);
    nums.clear();
    operators.clear();
    n = 0;
    maxLength = 0;
    hasAnswer = false;
}

void ArithmeticPuzzles::init()
{
    bool haveLetter[128] = {false};
    int flag = 1;   //+
    int sign = 1;
    int pre = 0, i = 0, len = equation.size();
    for(; i < len; i++) 
    {
        char c = equation[i];
        if(c == '+' || c == '-' || c == '=' ) 
        {
            nums.push_back(equation.substr(pre, i - pre));
            operators.push_back(sign);
            maxLength = max(i-pre, maxLength);
            if(c == '-')
                sign = -flag;
            else if(c == '=')
            {
                flag = -flag;
                sign = flag;
            }   
            if(i - pre > 1) 
                notZero[equation[pre]] = true;
            pre = i + 1;
        }
        else
            haveLetter[c] = true;
    }
    nums.push_back(equation.substr(pre, len - pre));
    operators.push_back(sign);
    if(len - pre > 1)
        notZero[equation[pre]] = true;
    maxLength = max(len-pre, maxLength);
    n = nums.size();
    // 单词翻转
    for(int i = 0; i < n; i++)
        reverse(nums[i].begin(), nums[i].end());

    for(int c = 0; c < 128; c++)
        if(haveLetter[c])
            letters.push_back(c);
};


void ArithmeticPuzzles::disp()
{
    if( !hasAnswer )
        cout << "no solution\n";
    else
    {
        for(auto c : equation)
        {
            if( c != '+' && c != '-' && c != '=' )
                cout << result[c];
            else
                cout << c;
        }
        cout << endl;
    }
}

char ArithmeticPuzzles::getLetter(int i, int j)
{
    if(j > nums.size()-1 || i > nums[j].size()-1)
        return -1;
    return nums[j][i];
}

void ArithmeticPuzzles::UpdateAns()
{
    if(!hasAnswer)
    {
        result = value;
        hasAnswer = true;
        return;
    }
    for(char letter : letters)  // 按字典序
    {
        if(value[letter] < result[letter])
        {
            result = value;
            return;
        }
        else if(value[letter] > result[letter])
            break;
        else
            continue;
    }
}

void ArithmeticPuzzles::dfs(int i, int j, int s)
{
    if(i == maxLength)
    {
        if(s == 0)
        {
            UpdateAns();
        }
        return;
    }
    if(j == n)
    {
        if(s % 10 == 0)
        {
            dfs(i+1, 0, s/10);
        }
        return;
    }
    char letter = getLetter(i, j);
    if(letter == -1)    // 不存在
    {
        dfs(i, j+1, s);
        return;
    }   
    if(value[letter] != -1)
        dfs(i, j+1, s + value[letter]*operators[j]);
    else
    {
        int startNum = 0;
        if(notZero[letter])
            startNum = 1;
        for(int k = startNum; k <= 9; k++)
        {
            if( !useNum[k] )
            {
                useNum[k] = true;
                value[letter] = k;
                dfs(i, j+1, s + k*operators[j]);
                useNum[k] = false;
                value[letter] = -1;
            }
        }
    }
    return;
}

int main()
{
    string str;
    while(cin >> str)
    {
        clock_t t = clock();

        ArithmeticPuzzles arith(str);
        arith.init();
        arith.dfs(0, 0, 0);
        arith.disp();

        t = clock() - t;
        cout << "Elapse " << t  << " ms" << endl;
    }
    return 0;
}

对SEND+MORE=MONEY的运行时间为 2 ms。

优化二

上面优化搜索顺序之后的代码，比起第一种方法已经有了很大的改善，但是仍然有一种情况没有办法做到。当碰到下面这种形式时，就会超时：

A+B+C+D+E+F+G+HJJJJJJJJJJJJJJ=A+B+C+D+E+F+G+IJJJJJJJJJJJJJJ

对以上问题，前面两种方法的运行时间如下：

  • 第一种方法：85239ms
  • 优化一：12009ms

超时的原因是因为其中8个字母都在最低位出现了，所以全部进行了枚举。并且只有当计算到最高位时才能确定这两个数是否相等。
对于这种数据，我们仔细观察会发现其中ABCDEFGJ的值实际上无论等于多少都可以，需要注意的只有H和I的值。

举一个简单的例子：A+B+C=AB

由于等式左右两边都有在个位的B，所以B的取值并不会对计算个位的s产生影响。对于这样的字母我们称之为无用的字母。

对于上面那个会超时的例子，我们可以发现，除了H和I以外全部都是无用的字母。枚举他们的值完全是没有必要的，我们只在一个字母出现，并且有用时才去枚举它的值。

因此我们先做一次预处理，将所有无用的字母都标记出，在枚举时直接跳过。无用字母由每一列上的元素决定，比如 AAC+B=AB 在个位上B为无用字母，在十位上A为无用字母，在百位上没有无用字母。

当然这样做还有一个问题：某一种字母每一次出现都是无用的字母，那么当我们找到合法答案时，该字母并没有赋值。

此时我们将剩余的数字按照最小序依次赋值给它们即可。

因此原伪代码改为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
dfs(i, j, s):
    If (i == m + 1) Then
        If (s == 0) Then
            fillAns()   // 赋值剩余的数字
            UpdateAns()
        End If
        Return 
    End If
    If (j == n + 1) Then
        If (s % 10 == 0) Then
            dfs(i + 1, 1, s / 10) // 直接将w加入s
        End If
         Return 
    End If
    letter = getLetter(i, j) // 若该字母为无用的字母，则返回-1
    If (letter == -1) Then  // 处理无用的字母
        dfs(i, j + 1, s)
        Return ;
    End
    If (val[ letter ] != -1) Then
        dfs(i, j + 1, s + val[ letter ] * op[j])
    Else
        startNum = 0
        If (notZero[ letter ]) Then 
            startNum = 1
        End If
        For i = startNum .. 9
            If not useNum[i] Then
                useNum[i] = true
                val[ letter ] = i
                dfs(i, j + 1, s + val[ letter ] * op[j])
                val[ letter ] = -1
                useNum[i] = false
            End If
        End If
    End If

加上第二种优化之后，就解决特殊情况，也就能够顺利地通过所有的测试点了。

优化二的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <ctime>
#include <map>
using namespace std;

class ArithmeticPuzzles
{
public:
    ArithmeticPuzzles(const string s);
    ~ArithmeticPuzzles(){};

    void init();                      // 对变量进行初始化
    void dfs(int i, int j, int s);    // 深度搜索
    void disp();                      // 显示结果
    char getLetter(int i, int j);     // 获得(i,j)处的字母
    void UpdateAns();                 // 更新结果/答案
    void fillAns();

public:
    std::vector<char> letters;    // 出现的字母
private:
    string equation;
    std::vector<int> value;       // 每个字母对应的数字， 默认-1
    std::vector<bool> useNum;     // 是否使用过该数字
    std::vector<bool> notZero;    // 是否可以为0，不能：true， 能：false
    std::vector<string> nums;     // 以运算符分开的数字
    std::vector<int> operators;   // 运算符，与nums对应
    std::vector<int> result;      // 结果：保存字母对应的数字
    vector<vector<char>> useLess; // 存储每一列上的无用字符
    int n;              // 单词数量  
    int maxLength;      // 单词最大长度
    bool hasAnswer;     // 是否有解
};

ArithmeticPuzzles::ArithmeticPuzzles(string str) : equation(str)
{
    value.resize(128, -1);
    result.resize(128, -1);
    useNum.resize(10, false);
    notZero.resize(128, false);
    nums.clear();
    operators.clear();
    n = 0;
    maxLength = 0;
    hasAnswer = false;
}

void ArithmeticPuzzles::init()
{
    bool haveLetter[128] = {false};
    // flag,sign用来确定单词的运算符
    int flag = 1;   
    int sign = 1;
    int pre = 0, i = 0, len = equation.size();
    for(; i < len; i++) 
    {
        char c = equation[i];
        if(c == '+' || c == '-' || c == '=' ) 
        {
            nums.push_back(equation.substr(pre, i - pre));
            operators.push_back(sign);
            maxLength = max(i-pre, maxLength);
            if(c == '-')
                sign = -flag;
            else if(c == '=')
            {
                flag = -flag;
                sign = flag;
            }   
            if(i - pre > 1) 
                notZero[equation[pre]] = true;
            pre = i + 1;
        }
        else
            haveLetter[c] = true;
    }
    nums.push_back(equation.substr(pre, len - pre));
    operators.push_back(sign);
    if(len - pre > 1)
        notZero[equation[pre]] = true;
    maxLength = max(len-pre, maxLength);
    n = nums.size();
    // 单词翻转
    for(auto & num : nums)
        reverse(num.begin(), num.end());
    // 按字典序排列的字母
    for(int c = 0; c < 128; c++)
        if(haveLetter[c])
            letters.push_back(c);

    // 寻找每一列上的无用字母
    for(int i = 0; i < maxLength; i++)
    {
        map<char,int> opCount;  // 该字母的运算符出现的次数，'+'记为1，'-'记为-1.
        for(int j = 0; j < n; j++)
        {
            if(i > nums[j].size()-1)
                continue;
            opCount[nums[j][i]] += operators[j];
        }
        vector<char> useLessCol;
        for(map<char,int>::iterator it = opCount.begin(); it != opCount.end(); it++)
        {
            if(it->second == 0)    // '+' 与 '-'次数相同
                useLessCol.push_back(it->first);
        }
        useLess.push_back(useLessCol);
    }
};


void ArithmeticPuzzles::disp()
{
    if( !hasAnswer )
        cout << "No Solution\n";
    else
    {
        for(auto c : equation)
        {
            if( c != '+' && c != '-' && c != '=' )
                cout << result[c];
            else
                cout << c;
        }
        cout << endl;
    }
}

char ArithmeticPuzzles::getLetter(int i, int j)
{
    // 判断是否存在
    if(j > nums.size()-1 || i > nums[j].size()-1)
        return -1;
    // 判断该字母是否为无用字母
    for(auto c : useLess[i])
        if(c == nums[j][i])
            return -1;
    // 否则
    return nums[j][i];
}

void ArithmeticPuzzles::fillAns()
{
    for(auto letter: letters)
        if(value[letter] == -1)   // 无用字母
        {
            int startNum = notZero[letter] ? 1 : 0;
            for(int i = startNum; i <= 9; i++)
                if(!useNum[i])
                {
                    value[letter] = i;
                    useNum[i] = true;
                    break;
                }
        }
}

void ArithmeticPuzzles::UpdateAns()
{
    if(!hasAnswer)
    {
        result = value;
        hasAnswer = true;
        return;
    }
    for(char letter : letters)  // 按字典序比较
    {
        if(value[letter] < result[letter])
        {
            result = value;
            return;
        }
        else if(value[letter] > result[letter])
            break;
        else
            continue;
    }
}

void ArithmeticPuzzles::dfs(int i, int j, int s)
{
    if(i == maxLength)  // 最后一位
    {
        if(s == 0)
        {
            fillAns();
            UpdateAns();
        }
        return;
    }
    if(j == n)      // 每一位上的最后一个数
    {
        if(s % 10 == 0)
        {
            dfs(i+1, 0, s/10);   // 进入下一位,s/10表示进位
        }
        return;
    }
    char letter = getLetter(i, j);
    if(letter == -1)    // 无用的字母或不存在
    {
        dfs(i, j+1, s);
        return;
    }   
    if(value[letter] != -1)   // 该字母已赋值
        dfs(i, j+1, s + value[letter]*operators[j]);
    else
    {
        // 该字母未赋值，则枚举
        int startNum = notZero[letter] ? 1 : 0;
        for(int k = startNum; k <= 9; k++)
        {
            if( !useNum[k] )
            {
                useNum[k] = true;
                value[letter] = k;
                dfs(i, j+1, s + value[letter]*operators[j]);
                useNum[k] = false;
                value[letter] = -1;
            }
        }
    }
    return;
}

int main()
{
    int T;
    cin >>T;
    string str;
    while(T--)
    {
        cin >> str;
        ArithmeticPuzzles arith(str);
        arith.init();
        if(arith.letters.size() > 10)
        {
            cout << "No Solution\n";
            return 0;
        }
        arith.dfs(0, 0, 0);
        arith.disp();
    }
    return 0;
}

对SEND+MORE=MONEY的运行时间为 3 ms, 因为该表达式中没有出现无用字母，但对A+B+C+D+E+F+G+HJJJJJJJJJJJJJJ=A+B+C+D+E+F+G+IJJJJJJJJJJJJJJ的运行时间不到1ms，可以看出优化二对无用字母比较多的表达式处理很快。

题目总结

其实说了这么多，就两种思路解决本题。

思路一：按字典序给每一个字母赋值，然后带入表达式，如果正确，则结束运行，如果错误则进入下一个字典序。

思路二：先求解能满足表达式的结果，在结果中寻找字典序最小的一个并返回。

虽然只是在处理的顺序上不同了，但运行时间却很不同，第二种方法先求解满足表达式的结果，可以得到很大程度的剪枝，因为满足表达式的组合并不多，就算没有满足表达式的组合也能很快找到。然而，如果先遍历所有的字母组合，由于组合数太多，有10!个，最大的时间复杂度是O(10!)，是程序处理速度慢的主要原因。

本题是一道非常综合的题目，需要正确实现字符串处理、高精度加减法、深度优先搜索和一些剪枝优化，有不小的难度。

]]> Arithmetic Puzzles：给定一个由字母组成的等式，其中每一个字母表示一个数字。不同字母表示的数字一定不同。问字母和数字之间是否存在一一对应关系，使得等式成立。若存在多种方案输出按字母顺序排列后字典序最小的解。

比如 SEND+MORE=MONEY 的一个解为 9567+1085=10652。
]]>

<![CDATA[auto 与 decltype]]> http://allenyick.com/2015/11/30/auto-与-decltype/ 2015-11-30T13:56:26.000Z 2015-12-01T14:20:18.472Z 本文将介绍C++11中两个与类型有关的关键字，auto 与 decltype ，以及C++11中新提出的类型推导的概念。

1 auto

说到C++11的新特性，从使用方便的角度，不得不提的就是auto。auto在C++11中与C++98中完全是两种概念。在C++98中是一种存储类型指示符（storage-class-specifier,如static、extern、thread_local等）， 而在C++11中是一种新的类型指示符（type-specifier, 如int, float, char等）。只是，auto声明变量的类型必须由编译器在编译时期推导而得。另一个与类型有关的则是 decltype，下面分别介绍这两个关键字的用法。

1.1 auto类型推导

在编程语言中，C/C++常被冠以“静态类型”，的称号，而像Python类的语言则被称为“动态类型”的。通常情况下，“静”和“动”的区别非常直观。先看看如下的Python代码：

1
2
name = 'world\n'
print 'hello, %s' % name

这是Python的一个”hello world”实现。代码使用了一个变量name，在使用前并没有进行过任何声明，而当使用时，可以直接拿来就用。

1.1.1 静态类型和动态类型

这种变量的使用方式非常随性，而在C/C++程序员眼中，每个变量使用前都必须声明（或定义的同时声明）几乎是天经地义的事，这样通常被视为编程语言的 “静态类型” 的体现。而对于Python、Perl、JavaScript等语言中变量不需要声明，而几乎“拿来就用” 的变量方式，则被视为是编程语言中的 “动态类型” 的体现。不过从技术上严格地讲，静态类型和动态类型的主要区别在于对变量进行类型检查的时间点。对于静态类型，类型检查主要发生在编译阶段；而对于动态类型，类型检查主要发生在运行阶段。形如Python等语言中变量“拿来就用”的特性，则需要归功于一个技术，即类型推导。

事实上，类型推导也可以用与静态类型的语言中。比如在上面的 Python 代码中，即使没有对 name 进行事先的类型声明，如果按照 C/C++ 程序员的思考方式，”world\n”表达式应返回一个临时字符串，所以即使name没有进行类型声明，也能轻松推导出name的类型应该是一个字符串类型。在C++11中，重定义了auto关键字，实现了类型的推导，另一个实现是 decltype，将在后面详细叙述。

可以使用C++11的方式实现刚才的Python代码：

1
2
3
4
5
6
7
8
9
#include <iostream>
using namespace std;

int main()
{
    auto name = "world\n";
    cout << "hello, " << name;
}
// 编译选项: g++ -std=c++11 auto-test-1.cpp

这里使用了auto关键字来要求编译器对变量name的类型进行自动推导。编译器根据它的初始化表达式的类型，推导出name的类型为 char* 。

auto类型推导的基本用法：

1
2
3
4
5
6
7
8
9
10
11
12
int main()
{
    double foo();
    auto x = 1;     // x的类型为 int
    auto y = foo(); // y的类型为 double
    struct m { int i; }str;
    suto str1 = str;  // str1的类型是 struct m

    auto z;  //无法推导，无法通过编译 
    z = x;
}
// 编译选项: g++ -std=c++11 auto-test-2.cpp

变量x被初始化为1，因为字面常量1的类型为 const int，所以编译器推导出x的类型为int（这里const类型限制符被去掉了，后面会解释）。同理y被推导为double类型，str1被推导为struct m。而变量z，我们使用auto “声明” z，但不立即对其进行定义，此时编译器会报错。表明auto声明的变量必须被初始化，以使编译器能够从初始化表达式中推导出其类型。从这个意义上讲auto并非一种类型声明，而是一个类型声明时的占位符，编译器在编译时期会将auto替换为变量实际的类型。

1.2 auto的优势

1.2.1 简化复杂类型变量的声明

假如我们定义了这样的一个函数：

1
2
3
4
5
6
void loopover(std::vector<std::string> &vs)
{
    std::vector<std::string>::iterator i = vs.begin();
    for(; i != vs.end(); i++)
        // do something
}

我们以 vs.begin() 初始化迭代器i的值，然而在定义i的时候不得不写出 std::vector< std::string >::iterator 这样的声明。这样冗长的代码可读性自然很低，就算使用了 using namespace std，情况也好不到那里去， 如果使用auto的话，代码可读性可以成倍增加。

1
2
3
4
5
void loopover(std::vector<std::string> &vs)
{
    for( auto i = vs.begin(); i != vs.end(); i++)
        // do something
}

在for循环中，i 的类型将由vs.begin()推导出，这样的代码更清晰可读。

1.2.2 免除类型声明时的麻烦，避免类型声明时的错误

先看这样的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class PI{
public:
     double operator* (float v)
     {
         return (double)val * v;  // 这里扩展了精度
     }
     const float val = 3.1415927f;
};
int main()
{
   float radius = 1.7e10;
   PI pi;
   auto circumference = 2 * (pi * radius);
}

这里定义了 float 类型的变量 radius （半径）以及一个自定义类型的 PI 变量 pi ，使用 auto 类型定义变量 circumference ，在 pi 与 radius 相乘时，其返回值是 double。而 PI 的定义有可能在其他地方， main 函数作者也许为避免数据上溢或者精度降低而使用 double，这样不会有问题，而使用了 float 类型声明就可能享受不了 PI 作者细心设计带来的好处，将 circumference声明为auto则毫无问题。

1.2.3 自适应，支持泛型编程

当 auto 应用于模板的定义中，其“自适应”性会得到更加充分的体现。看看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template<typename T1, typename T2>
double Sum(T1 & t1, T2 & t2){
    auto s = t1 + t2;    // s 的类型会在模板实例化是被推导出来
    return s;
}

int main()
{
    int a = 1;
    long long b = 2LL;
    double c = 3.0f;
    double d = 4.0;

    auto e = Sum<int, long long>(a, b);      // e 的类型被推导为long
    auto f = Sum<double, double>(c, d);  // f 的类型被推导为double
}

由于T1、T2的类型要在模板实例化时才能确定，所以在Sum中将s声明为auto类型。

1.3 auto使用细则

1.3.1 auto类型指示符与指针和引用之间的关系

1
2
3
4
5
6
7
8
9
10
11
12
13
int x;
int * y = &x;
double foo();
int & bar();

auto * a= &x;   // a: int *
auto & b = x;   // b: int &
auto c = y;     // c: int *
auto * d = y;   // d: int *
auto * e = &foo();  // 指针不能指向临时变量
auto & f = foo();   // nonconst 的左值引用不能绑定一个临时变量
auto g = bar();     // g: int
auto & h = bar();   // h: int &

可以看出 auto* 与 auto 并没有什么区别，如果要使得auto声明的变量是另一个变量的引用，则必须使用 auto&。

1.3.2 auto 与 volatile 和 const 之间的关系

volatile 和 const 代表两种不同的属性：易失性和常量性，在C++标准中，它们常被一起叫做cv限制符（cv-qulifier）。

1
2
3
4
5
6
7
8
9
10
11
double foo();
float * bar();

const auto a = foo();         // a: const double
const auto & b = foo();       // b: cosnt double &
volatile auto * c = bar();    // c: volatile float *

auto d = a;                   // d: double
auto & e = a;                 // e: const double &
auto f = c;                   // f: float *
volatile auto & g = c;        // g: volatile float * &

可以看出，auto可以和cv限制符一起使用，可以通过非cv限制的类型初始化一个cv限制的类型。不过通过auto声明的变量d，f却无法带走a和f的常量性和易失性。这里的例外还是引用，可以看出，声明为引用的变量e，g都保持了其引用对象的属性。

1.3.3 auto的其他规则

此外，同一赋值语句中，auto可以用来声明多个变量的类型，不过这些变量的类型必须相同。如果类型不同，则会编译错误。事实上，用auto来声明多个变量是，只有第一个变量用于类型推导，然后推导出来的数据类型被作用于其他的变量。所以不允许这些变量的类型不同。其实每个 auto 都写一行是最好的做法，可读性也好。

1
2
3
4
5
6
7
8
auto i = 1, j = 2;  // i,j均为int

auto x = 1, y = 1.2f;    // 编译失败

auto o = 1, &p = o, *q = &p;  // 从左向右推导

// m是指向const int的指针，n是int型变量
const auto* m = &x, n = 1;

1.3.4 auto不能推导的情况

不过 auto 也不是万能的，受制于语法的二义性，或者是实现的困难性，auto往往也会有使用上的限制。这些例外写在下面的代码中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <vector>
using namespace std;

void fun(auto x = 1) {}  // 1: auto 函数参数，编译失败

struct str{
    auto var = 10;  // 2: auto 非静态成员，编译失败
};

int main()
{
    char x[3];
    auto y = x;
    auto z[3] = x;  // 3: auto 数组，编译失败

    // 4: auto 模板参数实例化时，编译失败
    vector<auto> v(2, 0);  
}

以上四种情况是auto不能推导的情况。

2 decltype

与auto类似，decltype 也能进行类型推导，不过这两者的使用方式却有一定的区别。先看如下这个简单的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include <typeinfo>
using namespace std;

int main()
{
    int i;
    decltype(i) j = 0;
    cout << typeid(j).name() << endl;  // 打印出"i", g++中表示int

    float a;
    double b;
    decltype(a+b) c;
    cout << typeid(c).name() << endl;  // 打印出"d", g++中表示double
}

我们看到变量j的类型由decltype(i)进行声明，表示j的类型跟i相同。而c的类型跟a+b这个表达式返回的类型相同。由于a+b返回double类型，则c也是double类型。

2.1 decltype的应用

与 typedef/using 合用，常看到这样的代码：

1
2
3
using size_t = decltype(sizeof(0));
using ptrdiff_t = decltype((int*)0 - (int*)0);
using nullptr_t = decltype(nullptr);

这里 size_t 以及 ptrdiff_t 还有 nullptr_t 都是由 decltype 推导出的类型。

除此之外，decltype 在某些场景下，可以极大地增加代码的可读性。

1
2
3
4
5
6
vector<int> vec;
typedef decltype(vec.begin()) vec_iter_type;
for(vec_iter_type i = vec.begin(); i != vec.end(); i++)
    // do something
for(decltype(vec)::iterator i = vec.begin(); i != vec.end(); i++)
    // do something

可以看到 decltype(vec)::iterator 这样灵活的用法，和 auto 非常类似，也类似一种“占位符”式的替代。

另外，在C++中，有时会遇到匿名的类型，而拥有了 decltype 这个利器之后，重用匿名类型也非难事。看看如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
enum class {K1, K2, K3} anon_e;   // enum class 为C++11新特性

union {
    decltype(anon_e) key;
    char* name;
}anon_u;  // 匿名的union联合体

struct {
    int d;
    decltype(anon_u) id;
}anon_s[100];  // 匿名的 struct 数组

int main()
{
    decltype(anon_s) as;
    as[0].id.key = decltype(anon_e)::K1;   // 引用匿名强类型枚举中的值
}
// 编译选项： g++ -std=c++11

进一步地，有了 decltype，可以适当扩大模板泛型的能力。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// s的类型被声明为 decltype(t1 + t2)
template<typename T1, typename T2>
void Sum(T1 & t1, T2 & t2, decltype(t1+t2) &s){
    s = t1 + t2;
}

int main()
{
    int a = 3;
    long long b = 5;
    float c = 1.0f, d = 2.4f;

    long long e;
    float f;
    Sum(a, b, e);  // s的类型被推导为long log
    Sum(c, d, f);  // s的类型被推导为float
}
// 编译选项： g++ -std=c++11

这样一来，Sum的适用范围增加，不过很明显，如果 t1 和 t2 是两个数组，t1+t2 不会是合法的表达式。因此应该为这些特殊情况提供其他的版本。

2.2 decltype 推导四规则

作为 auto 的伙伴，decltype 在C++11中也非常重要。不过跟auto一样，也有很多细则条款需要注意。最典型的例子如下：

1
2
3
4
int i;
decltype(i) a;    // a: int
decltype((i)) b;  // b: int &, 无法编译通过
// 编译选项： g++ -std=c++11

这里为什么编译器提示说 b 是 int & 类型？因为没有初始化所以编译出错。而 a 则被正确推导为 int 类型。decltype(e) 进行类型推导时，编译器将依序判断以下四规则：

  • 1）如果e是一个没有带括号的标记符表达式或者类成员访问表达式，那么 decltype(e) 就是 e 所命名的实体的类型。此外，如果 e 是一个被重载的函数，则会导致编译时错误。
  • 2）否则，假设 e 的类型是T，如果 e 是一个将亡值(xvalue)，那么 decltype(e) 为T&&。
  • 3）否则，假设 e 的类型是T，如果 e 是一个左值，则 decltype(e) 为T&。
  • 4）否则，假设 e 的类型是T，则 decltype(e) 为T。

再回到以上代码，并结合 decltype 的推导规则，就可以知道，decltype((i)) b; 中，由于 (i) 不是一个标记符表达式，但却是一个左值表达式，因此，按照 decltype 推导规则3，其类型是一个 int 的引用。

总的来说， decltype 算得上是C++11中类型推导使用方式上最灵活的一种。虽然看起来推导规则有些复杂，有的时候跟 auto 推导结果还略不相同，但大多数时候，deltype 还是自然而亲切的。一些细则的区别，可以在使用时遇到问题再返回查验。

在追踪返回类型的函数定义中，将融合 auto 与 decltype, 将C++11中的泛型能力提升到更高的水平。

]]> 本文将介绍C++11中两个与类型有关的关键字，auto 与 decltype ，以及C++11中新提出的类型推导的概念。

1 auto

说到C++11的新特性，从使用方便的角度，不得不提的就是auto。auto在C++11中与C++98中完全是两种概念。在C++98中是一种存储类型指示符（storage-class-specifier,如static、extern、thread_local等）， 而在C++11中是一种新的类型指示符（type-specifier, 如int, float, char等）。只是，auto声明变量的类型必须由编译器在编译时期推导而得。另一个与类型有关的则是 decltype，下面分别介绍这两个关键字的用法。
]]>

<![CDATA[Machine Learning 概览]]> http://allenyick.com/2015/11/29/Machine-Learning-概览/ 2015-11-29T02:16:12.000Z 2015-12-02T01:23:13.182Z 近些年来，得益于互联网的普及，我们可以非常轻松地获取大量文本、音乐、图片、视频等各种各样的数据。机器学习，就是让计算机具有像人一样的学习能力的技术，是从堆积如山的数据（大数据）中寻找有用知识的数据挖掘技术。通过运用机器学习技术，从视频数据库中寻找自己喜欢的视频资料，或者根据用户购买记录向用户推荐其他相关产品等成为了现实。接下来从宏观的角度对什么是机器学习做相应的介绍，并对机器学习的基本概念进行说明。

1 学习的种类

计算机的学习，根据所处理的数据种类的不同，可以分为监督学习、无监督学习和强化学习等几种类型。

监督学习，通俗的讲是指由求知欲的学生从老师那里获取知识、信息，老师提供对错提示，告知最终答案的过程。在机器学习中，学生对应于计算机，老师对应于周围环境。根据在学习过程中所获得的经验、技能，对没有学习过的问题也可以做出正确的回答，是计算机获得这种泛化能力，是监督学习的最终目标。监督学习，在手写文字识别、声音处理、图像处理、垃圾邮件分类与拦截，网页检索、基因诊断以及股票预测等各个方面，都有着广泛的应用。这一类机器学习的典型任务包括：预测数值型数据的回归，预测分类标签的分类，预测顺序的排序等。

无监督学习，是指在没有老师的指导下，学习自学的过程。在机器学习里，基本上都是计算机在互联网中自动收集信息，并从中获取有用的信息。无监督学习不仅仅局限于解决像监督学习那样的有明确答案的问题，因此，它的学习目标可以不必十分明确。无监督学习在人造卫星故障诊断、视频分析、社交网站解析和声音信号解析等方面大显身手的同时，在数据可视化以及作为监督学习方法的前处理工具方面，也有广泛的应用。这一类机器学习的典型任务有聚类、异常检测等。

强化学习，与监督学习类似，也以使计算机获得对没有学习过的问题作出正确解答的泛化能力为目标，但在学习过程中，不设置老师提示对错，告知最终答案的环节。然而，如果真的在学习过程中不能从环境中获得任何信息的话，强化学习就变成无监督学习了。强化学习，是指在没有老师直到的情况下，自己对预测的结果进行评估的方法。通过这样的自我评估，学生为了获得老师的最高嘉奖而不断地进行学习。强化学习，在机器人的自动控制、计算机游戏中的人工智能、市场战略的最优化等方面均有广泛的应用。在强化学习中国经常会用到回归、分类、聚类、和降维等各种机器学习算法。

2 机器学习任务的例子

下面主要讲解机器学习中典型的任务，例如回归、分类、聚类、异常检测、聚类和降维等。

回归，是指把实函数在样本点附近加以近似的有监督的函数近似问题。考虑以$d$维实向量$\boldsymbol{x}$作为输入，实数值$y_i$作为输出的函数$ y=f(\boldsymbol{x}) $的学习问题。在监督学习里，这里的真实函数关系$f$是未知的，作为训练集的输入输出样本$\{({x_i}, y_i)\}_{i=1}^{n}$是已知的。

分类，是指对于指定的模式进行识别的有监督的模式识别问题。在这里，以$d$维实向量$\boldsymbol{x}$作为输入样本，而所有的输入样本，可以划分为$c$个类别的问题进行说明，作为训练集的输入输出样本$\{({x_i}, y_i)\}_{i=1}^{n}$是已知的。但是，分类问题中的输出样本$y_i$，并不是具体的实数，而是分别代表类别$ 1,2, \ldots ,c $。在这样的任务里，得到输出类别$1,2, \ldots ,c$的函数$ y=f(\boldsymbol{x}) $的过程。

异常检测，是指寻找输入样本$\{({x_i})\}_{i=1}^{n}$中所包含的异常数据的问题。在已知正常数据与异常数据例子的情况下，其与有监督的分类问题是相同的。但是，在一般情况下，对于什么样的数据是异常的，什么样的数据是正常的，在事先是未知的。在这样的无监督的异常检测问题中，一般采用密度估计的方法，把靠近密度中心的数据作为正常数据，把偏离密度中心的数据作为异常数据。

聚类，与分类问题相同，也是模式识别问题，但是属于无监督学习的一种。即只给出输入样本$\{({x_i})\}_{i=1}^{n}$，然后判断各个样本分别属于$1,2, \ldots ,c$中的哪个簇。隶属于相同簇的样本之间具有相似性的性质，不同簇之间具有不同的性质。在聚类问题中，如何准确地计算样本之间的相似度是很重要的课题。

参考文献：
[1] 图解机器学习
[3] Semi-Supervised Learning Tutorial

]]> <![CDATA[Range Sum Query]]> http://allenyick.com/2015/11/28/Range-Sum-Query/ 2015-11-28T05:56:19.000Z 2015-12-16T07:32:36.053Z Range Sum Query, 对一个整数序列，给定范围对其求和。根据序列的维度可分为一维、二维和多维，根据元素是否可以改变分为Immutable和Mutable，我们只讨论一维和二维的情况。

1. 1D, Immutable（一维，数据不可变）

Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.

Example:
Given nums = [-2, 0, 3, -5, 2, -1]

sumRange(0, 2) -> 1
sumRange(2, 5) -> -1
sumRange(0, 5) -> -3
Note:

  1. You may assume that the array does not change.
  2. There are many calls to sumRange function.

Analysis

如果采取brute-force, 在每次query的时候，则需要用O(n)的时间复杂度计算sumRange(i, j)，整个时间复杂度就为O(n^2),这样做必然是会超时，因此这种方法不可行。

这种方法在每次query的时候都需要将i到j的元素累加，比如第一次query的是(0,2)，第二次query的是(0,3), 我们可以发现第二次的计算是可以利用第一次的结果的。因此可以对算法进行改进，在一开始进行适当的计算，并保存结果，在增加空间复杂度的前提下减小时间复杂度。最后在query的时候就可以节省大量时间了，那么关键是我们要保存什么信息呢？
可以发现：

1
sumRange(i, j) = sumRange(0, j) - sumRange(0, i-1)

假如我们已经计算了每个sumRange(0, k),那么我们既可以在O(1)的算法时间复杂度内完成query。计算所有的sumRange(0, k)可以利用动态规划，O(n)的时间即可完成。因此整个算法的时间复杂度为O(n)，空间复杂度也为O(n)。

Cpp Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class NumArray {
public:
    NumArray(vector<int> &nums) {
        int n = nums.size();
        cusums.resize(n+1, 0);  // cusums[0]=0
        for(int i = 1; i <= n; i++)
            cusums[i] += cusums[i-1] + nums[i-1];
    }
    int sumRange(int i, int j) {
        return cusums[j+1]-cusums[i];
    }   
private:
    vector<int> cusums;
};

// Your NumArray object will be instantiated and called as such:
// NumArray numArray(nums);
// numArray.sumRange(0, 1);
// numArray.sumRange(1, 2);

2. 2D, Immutable（二维，数据不可变）

Given a 2D matrix matrix, find the sum of the elements inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).
Range Sum Query 2D
The above rectangle (with the red border) is defined by (row1, col1) = (2, 1) and (row2, col2) = (4, 3), which contains sum = 8.

Example:
Given matrix = [
[3, 0, 1, 4, 2],
[5, 6, 3, 2, 1],
[1, 2, 0, 1, 5],
[4, 1, 0, 1, 7],
[1, 0, 3, 0, 5]
]
sumRegion(2, 1, 4, 3) -> 8
sumRegion(1, 1, 2, 2) -> 11
sumRegion(1, 2, 2, 4) -> 12
Note:
You may assume that the matrix does not change.
There are many calls to sumRegion function.
You may assume that row1 ≤ row2 and col1 ≤ col2.

Analysis

与1维的处理方法相同，只不过二维的情形需要O(n^2)的时间预处理。主要利用一下公式：

1
2
3
4
sumRegion(row1, col1, row2, col2) = 
                          sumRegion(0, 0, row2, col1)
                        + sumRegion(0, 0, row1, col2)
                        - sumRegion(0, 0, row1, col1)

在实际处理中，定义积分图矩阵integrogram的第一行和第一列为0,方便使用统一公式处理，不用讨论为0的情况。

Cpp Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class NumMatrix {
public:
    NumMatrix(vector<vector<int>> &matrix) {
        n = matrix.size();
        m = n != 0 ? matrix[0].size() : 0;
        integrogram.resize(n+1, vector<int>(m+1, 0));  // 第一行，第一列为0
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= m; j++)
            {
                integrogram[i][j] = integrogram[i-1][j] 
                                  + integrogram[i][j-1] 
                                  - integrogram[i-1][j-1]
                                  + matrix[i-1][j-1];
            }
        }
    }

    int sumRegion(int row1, int col1, int row2, int col2) {
        if(row1 < 0 || col1 < 0 || row2 > n || col2 > m)
            return 0;
        return integrogram[row2+1][col2+1] - integrogram[row2+1][col1] - integrogram[row1][col2+1] + integrogram[row1][col1];
    }
private:
    vector<vector<int>> integrogram;
    int n, m;
};


// Your NumMatrix object will be instantiated and called as such:
// NumMatrix numMatrix(matrix);
// numMatrix.sumRegion(0, 1, 2, 3);
// numMatrix.sumRegion(1, 2, 3, 4);

3. 1D, Mutable (一维，数据可变)

Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.

The update(i, val) function modifies nums by updating the element at index i to val.
Example:
Given nums = [1, 3, 5]

sumRange(0, 2) -> 9
update(1, 2)
sumRange(0, 2) -> 8
Note:

  1. The array is only modifiable by the update function.
  2. You may assume the number of calls to update and sumRange function is distributed evenly.

Analysis

在Immutable的基础上，增加了update(index, value)， 即可以改变序列中任何位置的值。显然如果再使用刚才的算法，由于update的最大时间复杂度为O(n),因此整个算法的时间复杂度就增加到了O(n^2),因此需要一个复杂度更低的算法。可以从两方面入手update和query。需要将这两个函数的复杂度都降低到O(logn)以下(包括O(logn))。前面已经提到过需要*事先进行一些预处理，使得一些重复计算的东西不再重复计算，才能够将复杂度降低下来。

先预先计算一些区间的和值，然后把每个询问都拆成若干个计算了和的区间，并且将这些区间的和再相加，从而得出答案。这不就是线段树的思想吗？那就先从线段树说起。

线段树其实本质就是用一棵树来维护一段区间上和某个子区间相关的值——例如区间和、区间最大最小值一类的。它的具体做法是这样的，这棵树的根节点表示了整段区间，根节点的左儿子节点表示了这段区间的前半部分，根节点的右儿子节点表示了这段区间的后半部分——并以此类推，对于这棵树的每个节点，如果这个节点所表示的区间的长度大于1，则令其左儿子节点表示这段区间的前半部分，令其右儿子表示这段区间的后半部分。以一段长度为10的区间为例，所建立出的线段树应该是这样子的。
segment tree
就以RSQ(Range Sum Query)问题为例吧——RSQ问题要求的是求解一段区间中的和值，那么我不妨效仿ST算法，先对一些可能会用到的区间求解这个和值！而既然我要是用线段树来解决这个问题的，那么我不妨就将每一个节点对应的区间中的和值都求解出来。

那给定这样一组数据，将这个预处理的结果给我计算一下？
N=10
Weight = {3, 2, 9, 6, 7, 5, 4, 1, 8, 10}
这数据正好也只有10个位置，那么直接用这棵树了。由于每个非叶子节点所对应的区间都正好由它的两个儿子节点所对应的区间拼凑而成，这样一个节点所对应的区间中的和值便是它的两个儿子节点所对应的区间的和。这样我只需要O(N)的时间复杂度就可以计算出这棵树来。”

这样一棵树统计出来的区间怎样使用很快的算法进行查询？还有修改呢？”

先从简单的说起吧——修改，当某个位置的商品的重量发生改变的时候，对应的，就是这棵树的某个叶子节点的值发生了变化，包含这个节点的区间，便只有这个节点的所有祖先节点，而这样的节点数量事实上是很少的——只有O(log(N))级别。也就是说，当一次修改操作发生的时候，我只需要改变数量在O(log(N))级别的节点的值就可以完成操作了，修改的时间复杂度是O(log(N))。”

查询这个问题其实也不复杂！从线段树的根开始，对于当前访问的线段树节点t, 设其对应的区间为[A, B], 如果询问的区间[l, r]完全处于前半段或者后半段——即r <= (A + B)/2或者l > (A + B) / 2，那么递归进入t对应的子节点进行处理（因为另一棵子树中显然不会有任何区间需要用到）。否则的话，则把询问区间分成2部分[l, (A + B) / 2]和[(A + B) / 2 + 1, r]，并且分别进入t的左右子树处理这两段询问区间（因为2棵子树中显然都有区间需要用到）！当然了，如果[A, B]正好覆盖了[l, r]的话，就可以直接返回之前计算的t这棵子树中的和值了。还是之前那个例子，如果我要询问[3, 9]这段区间，我的最终结果会是这样的——橙色部分标注的区间。

首先[3, 9]分解成了[3, 5]和[6, 9]两个区间，而[3, 5]分解成了[3, 3]和[4, 5]——均没有必要继续分解，[6, 9]分解成了[6, 8]和[9, 9]——同样也没有必要继续分解了。每一步的分解都是必要的，所以这已经是最好的分解方法了。”

但是这样分解的话，区间的个数能保证么？万一很多怎么办？其实不会的，除了第一次分解成2个区间的操作可能会将区间个数翻倍外，之后每一次分解的时候所处理的区间都肯定有一条边是和当前节点对应的重合的（即l=A或者r=B），也就是说即使再进行分解，分解出的两个区间中也一定会有一个区间是不需要再进行分解的，也就是区间的总数是在深度这个级别的，所以也是O(logN)的。

再总结一下，首先根据初始数据，使用O(N)的时间构建一棵最原始的线段树，这个过程中我会使用子节点的值来计算父亲节点的值，从而避免冗余计算。然后对于每一次操作，如果是一次修改的话，我就将修改的节点和这个节点的所有祖先节点的值都进行更新，可以用O(logN)的时间复杂度完成。而如果是一次询问的话，使用上面描述的方法来对询问区间进行分解，用O(logN)的时间复杂度完成。无论是修改还是查询的时间复杂度都是O(logN)的，所以我这个算法最终的时间复杂度会是O(N + Q * log(N))。

Cpp Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
class NumArray {
public:
    // 构建SegmentTree
    NumArray(vector<int> &nums) {
        n = nums.size();
        segmentTree.resize(n * 4 + 1);   // 4n的空间足够存储SegmentTree
        createTree(0, 0, n-1, nums);
    }
    // 修改
    void update(int i, int val) {
        update(0, 0, n-1, i, val);
    }
    // 查询
    int sumRange(int i, int j) {
        if(i < 0 || j > n-1)
            return 0;
        return query(0, 0, n-1, i, j);
    }
private:
    // 沿根结点向下查询
    int query(int node, int begin, int end, int i, int j)
    {
        if(begin == i && end == j)
            return segmentTree[node];
        int mid = (begin+end) >> 1;
        if(j <= mid)    // 位于左子树
            return query((node<<1)+1, begin, mid, i, j);
        else if(i > mid) // 位于右子树
            return query((node<<1)+2, mid+1, end, i, j);
        else  // 位于左子树和右子树
            return query((node<<1)+1, begin, mid, i, mid)
        + query((node<<1)+2, mid+1, end, mid+1, j);
    }
    // 沿着根结点向下更新，直到叶子结点
    void update(int node, int begin, int end, int id, int val)
    {
        if(id < begin || id > end)
            return;
        if(begin == end)
            segmentTree[node] = val;
        else
        {
            update((node<<1)+1, begin, (begin+end)>>1, id, val);
            update((node<<1)+2, ((begin+end)>>1)+1, end, id, val);
            segmentTree[node] = segmentTree[(node<<1)+1] + segmentTree[(node<<1)+2];
        }
    }
    // 创建SegmentTree
    void createTree(int node, int begin, int end, const vector<int>& nums)
    {
        if(end < begin)   // illegal
            return;
        if(begin == end) //叶子结点
            segmentTree[node] = nums[begin];
        else
        {
            // 递归构建左右子树
            createTree((node << 1)+1, begin, (begin+end)>>1, nums);
            createTree((node<<1)+2, ((begin+end)>>1)+1, end, nums);
            segmentTree[node] = segmentTree[(node<<1)+1] + segmentTree[(node<<1)+2];
        }
    }
private:
    vector<int> segmentTree;
    int n;
};

// Your NumArray object will be instantiated and called as such:
// NumArray numArray(nums);
// numArray.sumRange(0, 1);
// numArray.update(1, 10);
// numArray.sumRange(1, 2);

Summary
对于本题，有人提出了一种基于bucket的方法，更新和查询分别需要O(1)和O(n^0.5)时间复杂度的算法(more)如果将求和该为求最大或最小值，即变成了RMQ问题，同样的算法，只需修改几个地方，就不再赘述，对于RMQ，还有经典的ST算法。
另二维，数据可变的情况没有列出，读者可以自己思考。

]]> Range Sum Query, 对一个整数序列，给定范围对其求和。根据序列的维度可分为一维、二维和多维，根据元素是否可以改变分为Immutable和Mutable，我们只讨论一维和二维的情况。
]]> <![CDATA[Additive Number]]> http://allenyick.com/2015/11/27/Additive-number/ 2015-11-27T05:03:02.000Z 2015-11-29T07:09:35.152Z Source

Additive number is a string whose digits can form additive sequence.

A valid additive sequence should contain at least three numbers. Except for the first two numbers, each subsequent number in the sequence must be the sum of the preceding two.

For example:
“112358” is an additive number because the digits can form an additive sequence: 1, 1, 2, 3, 5, 8.
1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8

“199100199” is also an additive number, the additive sequence is: 1, 99, 100, 199.
1 + 99 = 100, 99 + 100 = 199

Note: Numbers in the additive sequence cannot have leading zeros, so sequence 1, 2, 03 or 1, 02, 3 is invalid.

Given a string containing only digits ‘0’-‘9’, write a function to determine if it’s an additive number.
More: leetcode

My Solution

给定一个字符串，该字符串只包含0~9的字符，判断该字符串会否为“可加”的。“可加”的定义如下：将字符串序列分解为整数（至少三个），除了前两个，其余的每个数都是它前两个数之和。
根据字符串的不同分解，可构造一棵解答树，再利用深度优先搜索寻找答案，注意处理以下几点。

  • ‘0x’是非法的；
  • 数的长度越长，值越大，利用此性质可以有效的剪枝；
  • 至少包含三个数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class Solution {
public:
    bool isAdditiveNumber(string num) {
        int n = num.size();
        if(n < 3 )          // three numbers at least
            return false;
        for(int i = 1; i < n-1; i++)
        {
            if(num[0] == '0' && i > 1)   // "0x" is illegal
                break;
            for(int j = 1; i+j < n; j++)
            {
                if(num[i] == '0' && j > 1)
                    break;
                int first = str2int(num.substr(0, i));
                int second = str2int(num.substr(i, j));
                if(dfs(num, first, second, i+j))
                    return true;
            }
        }
        return false;
    }
private:
    // depth-first search
    bool dfs(string num, int first, int second, int idx)
    {
        if(first+second == str2int(num.substr(idx)))
            return true;
        for(int i = 1; i < num.size()-idx+1; i++)
        {
            if(num[idx] == '0' && i > 1)
                break;
            int third = str2int(num.substr(idx, i));
            if(first+second == third)
            {
                if(dfs(num, second, third, idx+i))
                    return true;
            }
            if(first+second < third) 
                break;
        }
        return false;
    }
    // string to int
    int str2int(string str)
    {
        int n = str.size();  
        if(n == 0 || (str[0] == '0' && n > 1) )
            return -1;
        int res = 0;
        for(int i = 0; i < str.size(); i++)
            res = res*10 + (str[i] - '0');
        return res;
    }
};
]]> Source

Additive number is a string whose digits can form additive sequence.

A valid additive sequence should contain at least three numbers. Except for the first two numbers, each subsequent number in the sequence must be the sum of the preceding two.

For example:
“112358” is an additive number because the digits can form an additive sequence: 1, 1, 2, 3, 5, 8.
1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8

“199100199” is also an additive number, the additive sequence is: 1, 99, 100, 199.
1 + 99 = 100, 99 + 100 = 199

Note: Numbers in the additive sequence cannot have leading zeros, so sequence 1, 2, 03 or 1, 02, 3 is invalid.

Given a string containing only digits ‘0’-‘9’, write a function to determine if it’s an additive number.
More: leetcode

]]>