JZ45，46，47，48

JZ45

输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。

#include <sstream>
class Solution {
public:
    string minNumber(vector<int>& nums) {
        quicksort(nums,0,nums.size()-1);
        stringstream ss;
        for(int i=0;i<nums.size();i++)
        {
            ss<<nums[i];            
        }
        return ss.str();
    }

    void quicksort(vector<int> &nums, int first, int last)
    {
        if(first>=last)
            return;
        int l = first;
        int r = last;;
        int temp = nums[l];
        while(l<r)
        {
            while(compare(nums[r], temp) && l<r)
            {
                r--;
            }
            nums[l]=nums[r];
            while(compare(temp,nums[l]) && l<r)
            {
                l++;
            }
            nums[r]=nums[l];
            
        }
        nums[l]=temp;
        quicksort(nums,first,l-1);
        quicksort(nums,l+1,last);
    }

    bool compare(int a,int b)
    {
        stringstream ss;
        ss<<a;
        string stra,strb;
        ss>>stra;
        ss.clear();
        ss<<b;
        ss>>strb;
        string str1=stra+strb;
        string str2=strb+stra;
        long num1 = atol(str1.c_str());
        long num2 = atol(str2.c_str());
        if(num1>=num2)
            return true;
        else
            return false;
    }
    
};

主要就是想到a+b<b+a则a<b的比较方法。

然后按照此自定义的大小比较方法进行快排排序即可。

JZ46

给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。

class Solution {
public:
    int translateNum(long num) {
        int n1=1;
        int n2=1;
        string str = to_string(num);
        int index = str.size()-1;
        for(int i=1;i<str.size();i++)
        {
            if(str[index-i]<'2' && str[index-i]!='0')
            {
                int temp = n1+n2;
                n1=n2;
                n2=temp;
            }
            else if(str[index-i]=='2')
            {
                if(str[index-i+1]<='5')
                {
                    int temp = n1+n2;
                    n1=n2;
                    n2=temp;
                }
            }
            else
            {
                n1=n2;
            }
        }
        return n2;
    }
    
};

JZ47

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

简单的动态规划题。

class Solution {
public:
    int maxValue(vector<vector<int>>& grid) {
        for(int i=0;i<grid.size();i++)
        {
            for(int j=0;j<grid[i].size();j++)
            {
               if(i==0)
               {
                    if(j==0)
                        continue;
                    else
                    {
                        grid[i][j]+=grid[i][j-1];
                    }
               } 
               else
               {
                   if(j==0)
                   {
                       grid[i][j]+=grid[i-1][j];
                   }
                   else
                   {
                       grid[i][j]+=(grid[i-1][j]>grid[i][j-1]?grid[i-1][j]:grid[i][j-1]);
                   }
               }
            }
        }
        return grid[grid.size()-1][grid[0].size()-1];
    }
};

JZ48

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

第一个是使用的是滑动窗口，第二个是题解中的动态规划思路代码。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        
        int result = 0;
        int p=0;
        while(1)
        {
            vector<int> array(128,-1);
            int size=0;
            while(p+size<s.size())
            {
                if(array[s[p+size]]==-1)
                {
                    array[s[p+size]]=p+size;
                    size++;
                    if(size > result)
                        result = size;
                }
                else
                {
                    p=array[s[p+size]]+1;
                    break;
                }
            }
            if(p+size>=s.size())
                break;
        }
        return result;
    }
};

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        vector<int> record(128,-1);
        vector<int> dp(s.size()+1,0);
        int p=0;
        int result=0;
        for(int i=1;i<=s.size();i++)
        {
            if(record[s[i-1]]==-1)
            {
                record[s[i-1]]=i-1;
                dp[i]=dp[i-1]+1;
                if(dp[i]>result)
                    result=dp[i];
            }
            else
            {
                if(record[s[i-1]]>=p)
                {
                    p=record[s[i-1]];
                    record[s[i-1]]=i-1;
                    dp[i]=i-p-1;
                }
                else
                {
                    record[s[i-1]]=i-1;
                    dp[i]=dp[i-1]+1;
                    if(dp[i]>result)
                        result=dp[i];
                }
            }
        }
        return result;
    }
};