Leetcode题解（十）

29、Divide Two Integers

题目

题目要求不用乘除和取模运算，实现两个整数相除；

我的第一想法就是把除法变成减法来做，这也是最初除法的定义，其实现代码如下：

class Solution {
public:
    int divide(int dividend, int divisor) {
        if(1 == divisor)
            return dividend;
        if (-1 == divisor)
            return 0-dividend;
        
        bool flag = false;

        if((dividend<0&&divisor>0))
        {
            dividend = 0-dividend;
            flag = true;
        }
        else if(dividend>0&&divisor<0)
        {
            divisor = 0-divisor;
            flag = true;
        }

        dividend = abs(dividend);
        divisor = abs(divisor);
        

        int result = 0;
        while (dividend >=divisor)
        {
            dividend -= divisor;
            result++;
        }
        if(flag)
            result = 0 - result;

        return result;

    }
};

看似没什么问题，但是其效率是不高的，比如被除数很大，而除数很小的时候，while循环会执行很多次，导致其效率不高，因此需要想想其他的办法解决该问题；既然直接做减法会超时，那姑且只能想移位操作了，因为移位操作是比较高效的操作，能够快速得到想要结果。如果是移位操作，应该如何下手呢？任何一个整数可以表示成以2的幂为底的一组基的线性组合，即num=a_0*2^0+a_1*2^1+a_2*2^2+...+a_n*2^n，在做除法时，dividend/divisor = num，变换一下就可以写成这样dividend = divisor*（a_0*2^0+a_1*2^1+a_2*2^2+...+a_n*2^n）；因此先让divisor左移n位，然后用dividend减去这个数，剩下的结果继续用同样的方法求解n-1，代码如下：

class Solution {
public:
   int divide(int dividend, int divisor) {
        // Note: The Solution object is instantiated only once.
        long long a = abs((double)dividend);
        long long b = abs((double)divisor);
        long long res = 0;
        while(a >= b)
        {
            long long c = b;
            for(int i = 0; a >= c; i++, c <<=1)
            {
                a -= c;
                res += 1<<i;
            }
        }
        
        
        if((dividend ^ divisor) >> 31) 
            res = 0-res;
        if(res >= 2147483647)
            return 2147483647;
        else
            return res;
        
    }
};

---------------------------------------------------------------------------------------------分割线--------------------------------------------------------------------------------

30、Substring with Concatenation of All Words

题目：

首先得弄懂题目的意思，这道题看了很久才弄明白题目意思：也就是说，给定一个字符串数组，数组中的字符串不管以什么顺序拼接在一起，得到新的字符串new，然后在s中查找new在s中第一次出现的下标，题目给的例子可以拼接成foobar或者barfoo，然后判断其起始下标分别为9,0；

按照上面说的，可以做n!次拼接，然后通过kmp算法判断在s中出现的下标，但是这种方式的效率太低，得想想其他方法，降低算法时间复杂度；

想了一会，想到了一个解决该问题的方法：依次遍历字符串s，第i（i从0开始）轮遍历时，也就是从s的s[i]开始，依次截取子字符串，截取长度为一个word的长度，然后判断words数组中是否有当前子字符串，如果没有，i++，如果存在，再从i+word.length处截取子字符串，以此类推；再判断子字符串是否存在时，可以通过一个map统计每个word出现的次数，遍历时，出现一个word，则对应次数加1，具体看代码实现：

class Solution {
public:
    vector<int> findSubstring(string S, vector<string> &L) {
        int l_size = L.size();
        
        if (l_size <= 0) {
            return vector<int>();
        }
        
        vector<int> result;
        map<string, int> word_count;
        int word_size = L[0].size();
        int i, j;
        
        for (i = 0; i < l_size; ++i) {
            ++word_count[L[i]];
        }
        
        map<string, int> counting;
        
        for (i = 0; i <= (int)S.length() - (l_size * word_size); ++i) {
            counting.clear();
            
            for (j = 0; j < l_size; ++j) {
                string word = S.substr(i + j * word_size, word_size);
                
                if (word_count.find(word) != word_count.end()) {
                    ++counting[word];
                    
                    if (counting[word] > word_count[word]) {
                        break;
                    }
                }
                else {
                    break;
                }
            }
            
            if (j == l_size) {
                result.push_back(i);
            }
        }
        
        return result;
    }
};