problem 1 -- Two sum

很简单。没什么好说的。

主要学习了STL的find_if、binary_search、和sort函数。

template <class InputIterator, class UnaryPredicate>
   InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred);

实现等价于：

template<class InputIterator, class UnaryPredicate>
  InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    if (pred(*first)) return first;
    ++first;
  }
  return last;
}

第三个参数pred是个函数指针或者函数对象，它的返回值应当可转化为bool类型，参数只有一个且应当声明为const。

find_if函数的返回值为(1)如果找到了，返回指向它的迭代器，(2)否则，返回last。

template <class ForwardIterator, class T>
  bool binary_search (ForwardIterator first, ForwardIterator last,
                      const T& val);

template <class ForwardIterator, class T, class Compare>
  bool binary_search (ForwardIterator first, ForwardIterator last,
                      const T& val, Compare comp);

实现等价于：

template <class ForwardIterator, class T>
  bool binary_search (ForwardIterator first, ForwardIterator last, const T& val)
{
  first = std::lower_bound(first,last,val);
  return (first!=last && !(val<*first));
}

binary_search函数的第三个参数为要查找的目标值。第四个参数为函数指针或者函数对象。它需要两个参数，返回一个bool型。

对于第一个版本，只有三个参数，使用operator < 函数来进行比较。第二个版本有四个参数，用第四个参数进行比较。

对于第一个版本，如果!(a < b) && !(b < a)那么a就与b相等。第二个版本类似，(!comp(a, b) && !comp(b, a)), 那么a与b相等。

与find_if函数区别之一是： binary_search返回的是bool型而不是迭代器。所以binary_search函数只知道是否有这个值而无法得到准确的位置

　　　　　　  区别之二是：binary_search使用之前需要先排序。

如果迭代器不是random-access的也没关系，因为内部使用的是advance函数，只是这样复杂度就是o(n)了

template <class RandomAccessIterator>
  void sort (RandomAccessIterator first, RandomAccessIterator last);

template <class RandomAccessIterator, class Compare>
  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

第三个参数是函数指针或者函数对象。
返回值是bool型，如果为真，表示a和b的偏序关系正确，为假表示不正确，需要交换。

完整代码如下：

class Solution {

struct MyStruct {
    int data;
    int original_pos;
};    

struct MyPred {
    MyPred(int d): data(d){}
    int data;
    bool operator() (MyStruct& tmp) {
        return tmp.data == data;
    }
};

public:
    vector<int>     twoSum(vector<int> &numbers, int target);
    static bool myCmp(const MyStruct &a, const MyStruct &b) {
        return a.data < b.data;
    }
private:

};

vector<int>    Solution::twoSum(vector<int> &numbers, int target) {
    vector<MyStruct>::iterator it;
    vector<MyStruct>::iterator pos;
    vector<MyStruct>    myStructVec;
    MyPred         myPred(target);

    int index = 1;
    for (vector<int>::iterator it = numbers.begin(); it != numbers.end(); it++, ++index) {
        MyStruct tmp;
        tmp.data = *it;
        tmp.original_pos = index;
        myStructVec.push_back(tmp);
    }
    sort(myStructVec.begin(), myStructVec.end(), myCmp);

    for (it = myStructVec.begin(); it != myStructVec.end(); it ++) {
        myPred.data = target - it->data;
        if (myPred.data < it->data) {
            it = myStructVec.end();
            break;
        }
        if ((pos = find_if(it + 1, myStructVec.end(), myPred)) != myStructVec.end())
            break;
    }

    vector<int> ans;
    if (it != myStructVec.end()) {
        if (it->original_pos > pos->original_pos)
            swap(it, pos);
        ans.push_back(it->original_pos);
        ans.push_back(pos->original_pos);
    }

    return ans;
}