1.Two Sum (Array; Divide-and-Conquer)

struct MyStruct {
    int data;
    int pos;
    MyStruct(int d, int p){
        data = d;
        pos = p;
    }
    bool operator < (const MyStruct& rf) const{//参数用引用：避免占用过大内存，并且避免拷贝；用const防止改变操作数
        if(data < rf.data) return true;
        else return false;
    }
};
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<MyStruct> myNums;
        vector<int> ret;
        int idx1 = 0, idx2;
        for(int i = 0; i < nums.size(); i++){
            MyStruct* num = new MyStruct(nums[i],i);
            myNums.push_back(*num);
        }
        
        sort(myNums.begin(),myNums.end());
        while(!binarySearch(myNums, target-myNums[idx1].data, idx1+1, nums.size()-1, idx2)){
            idx1++;
        }
        
        ret.clear();
        if(myNums[idx1].pos < idx2){
            ret.push_back(myNums[idx1].pos+1);
            ret.push_back(idx2+1);
        }
        else{
            ret.push_back(idx2+1);
            ret.push_back(myNums[idx1].pos+1);
        }
        return ret; 
    }
    
    bool binarySearch(const vector<MyStruct>& nums, const int& target, int start, int end, int& targetPos)
    {
        if(end - start == 1){
            if(nums[start].data == target){
                targetPos = nums[start].pos;
                return true;
            }
            else if(nums[end].data == target){
                targetPos = nums[end].pos;
                return true;
            }
            else return false;
        }
        
        int mid = (start + end) >> 1;
        if(nums[mid].data == target){
            targetPos = nums[mid].pos;
            return true;
        } 
        
        if(nums[mid].data > target && start != mid && binarySearch(nums, target, start, mid, targetPos)) return true;
        if(binarySearch(nums, target, mid, end, targetPos)) return true;
        
        return false;
    }
};