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

本文链接：https://blog.csdn.net/weixin_43064827/article/details/121565340

这篇博客详细介绍了LeetCode中的四道经典算法题目的解法，包括使用递归和迭代实现的快速幂、动态规划求解最大子序和、螺旋矩阵的遍历以及滑动窗口在找子串问题中的应用。内容涵盖了数据结构和算法的基础知识，适合提升编程技能。

摘要由CSDN通过智能技术生成

LeetCode打卡

一、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<nums.size();i++){
            pre=max(pre+nums[i],nums[i]);
            resMax=max(pre,resMax);
        }
        return resMax;
        */
        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;
    }
};