算法刷题计划（十五）Pow(x, n)、最大子序列和、螺旋矩阵、串联所有单词的子串（回顾滑动窗口）

一、Pow(x,n);

• 题目：
  

• 题解：

• 方法一（递归+快速幂）：
  

class Solution {
     
public:
    double myPow(double x, int n) {
     
        if(n==0)    return 1;
        long long N=n;
        return N>0?quickPri(x,N):1/quickPri(x,-N);
    }
    double quickDfs(double x,int n){
     
        if(n==0){
     
            return 1;
        }
        double y=quickDfs(x,n/2);
        n%2==0?y*=y:y*=y*x;
        return y;
    }
 }

• 方法二（迭代+快速幂）：
  

    double quickPri(double x,long long n){
     
        double y=1;
        double x1=x;
        while(n>0){
     
            if(n%2==1){
     
                y*=x1;
            }
            x1*=x1;
            n=n/2;
        }
        return y;
    }

---

二、最大子序和

• 题目：
  

• 题解：

• 方法一（动态规划）：

class Solution {
     
public:
    int maxSubArray(vector<int>& nums) {
     
        /*
        int pre=0,resMax=nums[0];
        for(int i =0;i
        vector<int>dp(nums.size());
        dp[0]=nums[0];
        int resMax=nums[0];
        for(int i=1;i<nums.size();i++){
     
            dp[i]=max(dp[i-1]+nums[i],nums[i]);
            resMax=max(dp[i],resMax);
        }
        return resMax;
    }
};

---

三、螺旋矩阵

• 题目：
  
• 题解：

class Solution {
     
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
     
        if(matrix.empty())  return {
     };
        if(matrix.size()==1)    return {
     matrix[0]};
        int left =0;
        int right=matrix[0].size()-1;
        int top=0;
        int bottom=matrix.size()-1;
        vector<int>res;
        int len=matrix[0].size()*matrix.size();
        while(len>=1){
     
            for(int i=left;i<=right&&len>=1;i++){
     
                res.emplace_back(matrix[top][i]);
                len--;
            }
            top++;
            for(int i =top;i<=bottom&&len>=1;i++){
     
                res.emplace_back(matrix[i][right]);
                len--;
            }
            right--;
            for(int i =right;i>=left&&len>=1;i--){
     
                res.emplace_back(matrix[bottom][i]);
                len--;
            }
            bottom--;
            for(int i=bottom;i>=top&&len>=1;i--){
     
                res.emplace_back(matrix[i][left]);
                len--;
            }
            left++;
        }
        return res;
    }
};

---

四、串联所有单词的子串（回顾滑动窗口）

• 题目:
  

• 题解：

class Solution {
     
public:
    vector<int> findSubstring(string s, vector<string>& words) {
     
        if(s.size()==0||words.empty())  return {
     };
        int oneWordLen=words[0].size();
        int wordsLen=words.size();
        
        unordered_map<string,int>m1;
        vector<int>index;

        for(const auto&s:words)
            m1[s]++;

        for(int i=0;i<oneWordLen;i++){
     
            unordered_map<string,int>m2;      
            int left=i,right=i,count=0;
            while(right+oneWordLen<=s.size()){
     
                string str=s.substr(right,oneWordLen);
                right+=oneWordLen;
                if(m1[str]==0){
     
                    m2.clear();
                    left=right;
                    count=0;
                }else{
     
                    count++;
                    m2[str]++;
                    while(m2.at(str)>m1.at(str)){
     
                        string str1=s.substr(left,oneWordLen);
                        left+=oneWordLen;
                        m2[str1]--;
                        count--;
                    }
                    if(count==wordsLen)    index.emplace_back(left);
                }
            }
        }
        return index;
    }
};

扩展：

• unorderd_map底层是哈希表，能存储重复数据,有顺序
• unorderd_set底层是哈希表，不能存储重复数据，无顺序
• map和set底层都是红黑树，都不能存储重复数据，前者有顺序，后者无顺序。
• 因此在该题中，用unorderd_map比map存储数据快。