Leetcode(4)-Two Sum

01.Two Sum

//LeetCode, Two Sum hash存储每个数字的下标
class Solution {
public:
vector<int> twoSum(vector<int> &nums, int target) {
    unordered_map<int, int> mapping;
    vector<int> result;
    for (int i = 0; i < nums.size(); i++) {
        mapping[nums[i]] = i;
    }
    for (int i = 0; i < nums.size(); i++) {
        int gap = target - nums[i];
        if (mapping.find(gap) != mapping.end() && mapping[gap] > i) {
            result.push_back(i + 1);
            result.push_back(mapping[gap] + 1);
            break;
        }
    }
    return result;
    }
};

15 3sum
先升序排序，然后用第一重for循环确定第一个数字。
然后在第二重循环里，第二、第三个数字分别从两端往中间扫。
如果三个数的sum等于0，得到一组解。
如果三个数的sum小于0，说明需要增大，所以第二个数往右移。
如果三个数的sum大于0，说明需要减小，所以第三个数往左移。
注意要跳过相同元素，否则也会超时；

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int> > ret;
        int n = nums.size();
        sort(nums.begin(), nums.end());
        int sum = 0;
        int i,j,k;
        for(i=0; i<n; i++){
            //skip same i
            while(i > 0 && i < n && nums[i] == nums[i-1])
                i ++;
            j=i+1;k=n-1;
            while(j<k){
                sum = nums[i]+nums[j]+nums[k];
                if(sum==0){
                    vector<int> cur(3);
                    cur[0] = nums[i];
                    cur[1] = nums[j];
                    cur[2] = nums[k];
                    ret.push_back(cur);
                    j++; k--;
                    //skip same j
                    while(j < k && nums[j] == nums[j-1])
                        j ++;
                    //skip same k
                    while(k > j && nums[k] == nums[k+1])
                        k --;
                }
                else if(sum>0){
                    //sum大于0，说明需要减小，所以第三个数往左移
                    k--;
                    //skip same k
                    while(k > j && nums[k] == nums[k+1])
                        k--;
                }
                else{
                    //sum小于0，说明需要增大，所以第二个数往右移。
                    j++;
                    //skip same j
                    while(j < k && nums[j] == nums[j-1])
                        j++;
                }
            }
        }
        return ret;
    }
};

18 4sum
与3sum思路一致，也是扫描，此处使用三重循环；
注意去重；
[-3,-2,-1,0,0,1,2,3]
0
Output:
[[-3,-2,2,3],[-3,-1,1,3],[-3,0,0,3],[-3,0,1,2],[-3,0,1,2],[-2,-1,0,3],[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
Expected:
[[-3,-2,2,3],[-3,-1,1,3],[-3,0,0,3],[-3,0,1,2],[-2,-1,0,3],[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int> > ret;
        //去重！！！
        set<vector<int>> res;
        int n = nums.size();
        if(n<4) return ret;
        sort(nums.begin(), nums.end());
        int sum = 0;
        int i,j,k,h;
        for(i=0; i<n-2; i++){
            //skip same i
            while(i > 0 && i < n && nums[i] == nums[i-1])
                i ++;
            for(j=i+1; j<n-1; j++){
                k=j+1;h=n-1;
                while(k<h){
                    sum = nums[i]+nums[j]+nums[k]+nums[h];
                    if(sum==target){
                        vector<int> cur(4);
                        cur[0] = nums[i];
                        cur[1] = nums[j];
                        cur[2] = nums[k];
                        cur[3] = nums[h];
                        //集合是insert不是push_back了;
                        res.insert(cur);
                        k++; h--;
                        while(k < h && nums[k] == nums[k-1])
                            k++;
                        while(h > k && nums[h] == nums[h+1])
                            h--;
                    }
                    else if(sum>target){
                        h--;
                        while(h > k && nums[h] == nums[h+1])
                            h--;
                    }
                    else{
                        k++;
                        while(k < h && nums[k] == nums[k-1])
                            k++;
                    }
                }
            }
        }
        //格式化
        set<vector<int>>::iterator it = res.begin();    
        for(; it != res.end(); it++)    
            ret.push_back(*it);   
        return ret;
    }
};

79、word search
先要找到’首字母’,之后按走迷宫的方式探索以达到正确目标；..递归过程要改改、、、

class Solution {
public:
    //获取邻居位置
    vector<int> istheneighbor(vector<vector<char>>& board, vector<int> a, char b){
        int x = a[0];
        int y = a[1];
        vector<int> t;
        if((x+1<board.size()) && (board[x+1][y] == b))
        {
             t.push_back(x+1);
             t.push_back(y);
        }
        if((y+1<board[0].size()) && (board[x][y+1] == b))
        {
             t.push_back(x);
             t.push_back(y+1);
        }
        if((x-1>0) && (board[x-1][y] == b))
        {
             t.push_back(x-1);
             t.push_back(y);
        }
        if((y-1>0) && (board[x][y-1] == b))
        {
             t.push_back(x);
             t.push_back(y-1);
        }
        return t;
    }
    //获取首字母所在所有位置的列表
    vector<vector<int>> getalp(vector<vector<char>>& board, char a){
        vector<vector<int>>path;
        vector<int> t;
        for(int i=0; i< board.size(); i++)
        {
            for(int j=0; j < board[0].size(); j++)
            {
                if(board[i][j] == a)
                {
                    t.push_back(i);
                    t.push_back(j);
                    path.push_back(t);
                }
            }
        }
        return path;
    }
    //递归
    bool dp(vector<vector<char>>& board,vector<int> t,string word,int num){
        if(num == word.size()-1) return true;
        num++;
        vector<int> x = istheneighbor(board,t,num);
        if(x.size()==2) 
            dp(board,x,word,num);
        else 
            return false;
    }
    bool exist(vector<vector<char>>& board, string word) {
        vector<vector<int>> alp = getalp(board, word[0]);
        for(int i=0;i<alp.size();i++)
        {
            bool f = dp(board,alp[i],word,0);
            if(f == true)
                return true;
        }
        return false;
    }
};