leetcode--最大子序列和/最后一个单词的长度/加1/二进制求和

最大子序列和

题目链接：https://leetcode-cn.com/problems/maximum-subarray/

剑指offer上的题目，确实高频，之前腾讯和头条面试都有碰到过，刷题的时候能快速想到的就是动态规划：

用dp[i]表示以第i个数组元素为结尾的连续子数组的最大和

class Solution {
public:
    int maxSubArray(vector& nums) {
        int dp[nums.size()];
        memset(dp,0,sizeof(dp));
        int max_val=nums[0];
        dp[0]=nums[0];
        for(int i=1;imax_val)
                max_val=dp[i];
        }
        return max_val;
    }
};

注意使用memset初始化。

还有一种优化方法，使用动态规划的思路但是并不额外开辟动态dp数组。

class Solution {
public:
    int maxSubArray(vector& nums) {
        int max_val=nums[0];
        int sum=nums[0];
        for(int i=1;imax_val)
                max_val=sum;
        }
        return max_val;
    }
};

加点难度，求最大子序列和，并返回最大子序列的左右区间下标

#include 
#include 

using namespace std;
const int maxn=105;
vector vt(maxn);

typedef struct Data
{
    int left;
    int right;
    int sum;
    Data(int a,int b,int c):left(a),right(b),sum(c){}
}Data;

Data find_max_sequence(int i,int j)
{
    if(i==j)
        return Data(i,j,vt[i]);
    //记录最大和的左右区间下标
    int new_left=i;
    int new_right=i;
    
    int cursum=vt[i];
    int maxsum=cursum;

    while(++i<=j)
    {
        if(cursum<=0)
        {
            cursum=vt[i];
            new_left=i;
            new_right=i;
            continue;
        }
        cursum+=vt[i];
        if(cursum>maxsum)
        {
            maxsum=cursum;
            new_right=i;
        }
    }
    return Data(new_left,new_right,maxsum);
}

int main()
{
    int n;
    cin>>n;

    for(int i=0;i>vt[i];
    }

    Data res=find_max_sequence(0,n-1);
    cout<

 

最后一个单词的长度

题目链接：https://leetcode-cn.com/problems/length-of-last-word/

 

直接倒叙开始数即可，直至碰到第一个空格或者遍历完成。但要注意不要遗忘字符串末尾是空格的情况："a     "

class Solution {
public:
    int lengthOfLastWord(string s) {
        int res=0;
        int i=s.size()-1;
        //首先去除字符串末尾的所有空字符
        while(s[i]==' ')
            i--;
        //然后从后往前遍历，依次技术直到遇到空格或者遍历完成即可
        for(;i>=0;i--)
        {
            if(s[i]!=' ')
                res++;
            else
                return res;
        }
        return res;
    }
};

加一

题目链接：https://leetcode-cn.com/problems/plus-one/

如果最后一个元素不是9，那么就不会进位

只有最后一个元素是9，才会发生进位，并且要注意999+1=1000这种会改变数组长度的情况。

class Solution {
public:
    vector plusOne(vector& digits) {
        int len=digits.size()-1;
        if(digits[len]!=9)
            digits[len]++;
        else
        {
            digits[len]+=1;
            for(int i=len;i>0;i--)
            {
                if(digits[i]>9)
                {
                    digits[i-1]++;
                    digits[i]=0;
                }
                else
                    break;
            }
            if(digits[0]>9)
            {
                digits[0]=0;
                digits.insert(digits.begin(),1);
            }
        }
        return digits;
    }
};

二进制求和

题目链接：https://leetcode-cn.com/problems/add-binary/

可以参考这篇博客关于大整数加法的思路：https://www.cnblogs.com/wuqianling/p/5387099.html

对字符串反转，然后从头到末尾依次开始对字符转数字然后相加，注意进位问题。

class Solution {
public:
    string addBinary(string a, string b) {
        
        //反转字符换
        reverse(a.begin(),a.end());
        reverse(b.begin(),b.end());

        //给位数低的补0
        int len1=a.size();
        int len2=b.size();
        
        if(len1>=len2)
        {
            for(int i=0;i