每日5题（2020/10/7）

(1)把数组排成最小的数，通过字符串的字典序将数组排成最小的字符串

class Solution{
public:
	static bool cmp(int a, int b){
		if (to_string(a) + to_string(b) < to_string(b) + to_string(a)){
			return true;
		}
		else{
			return false;
		}
	}
	string findMin(vector<int> nums){
		sort(nums.begin(), nums.end(), cmp);  //cmp必须是static的函数
		string str;
		for (int i = 0; i < nums.size(); i++){
			str += to_string(nums[i]);
		}
		return str;
	}
};

（2）将一串数字翻译成字符串的方案数， dp  ，类似于上楼梯（多一些附加要求）

dp[i]=dp[i-1]+dp[i-2]

class Solution {
public:
    int getTranslationCount(string s) {
   /*     int n=s.size();
        if(!n){return 0;}
        if(n==1){return 1;}
        s=' '+s;
        vector<int>dp(n+1,0);
        dp[0]=dp[1]=1;
        for(int i=2;i<=n;++i){
            dp[i]=dp[i-1];
            if(s[i-1]=='1'||(s[i-1]=='2'&&s[i]<'6')){
                dp[i]+=dp[i-2];
            }
        }
        return dp[n];*/
        int n=s.size();
        if(!n){return 0;}
        if(n==1){return 1;}
        vector<int>dp(n+1,0);
        dp[n-1]=1;
        for(int i=n-2;i>=0;--i){
            dp[i]=dp[i+1];
            if(s[i]=='1'||(s[i]=='2'&&s[i+1]<'6')){
                dp[i]+=dp[i+2];
            }
        }
        return dp[0];
    }
};

　(3)求矩阵路径上的最大价值，dp方式    dp[i][j]=max(dp[i-1][j],dp[i][j-1])+grid[i][j];

更具dp数组和grid数组的重合方式有两种写法，（1）将dp的初始化分开写，（2）将dp的初始化和dp求解合在一起写

class Solution {
public:
    int getMaxValue(vector<vector<int>>& grid) {
        /*if(grid.empty()){
            return 0;
        }
        int n=grid.size();int m=grid[0].size();
        vector<vector<int>> dp(n,vector<int>(m,0));  //dp数组和grid数组下标重合时
        dp[0][0]=grid[0][0];
        for(int i=1;i<n;i++){          //可以通过上面和左面填充0元素统一写法
            dp[i][0]=dp[i-1][0]+grid[i][0];
        }
        for(int j=1;j<m;j++){
            dp[0][j]=dp[0][j-1]+grid[0][j];
        }
        for(int i=1;i<n;i++){
            for(int j=1;j<m;j++){
                dp[i][j]=max(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[n-1][m-1];*/
        if(grid.empty()){return 0;}
        int n=grid.size();int m=grid[0].size();
        vector<vector<int>>dp(n+1,vector<int>(m+1,0));
        dp[0][0]=0;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                dp[i][j]=max(dp[i-1][j],dp[i][j-1])+grid[i-1][j-1];
            }
        }
        return dp[n][m];
    }
};

（4）求字符串中的不含重复字符的最长字符子串    双指针法，通过unordered_map<char,int>记录每一个字符出现的次数

class Solution {
public:
    int longestSubstringWithoutDuplication(string s) {
        unordered_map<char,int>hash;
        int res=0;
        for(int i=0,j=0;j<s.size();j++){
            hash[s[j]]++;
            while(hash[s[j]]>1){
                hash[s[i++]]--;
            }
            res=max(res,j-i+1);
        }
        return res;
    }
};

（5）丑数　：一个数的质因数（因数为质数）全部都是2,3,5的数为丑数

求出第n个丑数       三路归并，一个数的因数都为质数的数  丑数

class Solution {
public:
    int getUglyNumber(int n) {
        if(n<=1){
            return 1;
        }
        vector<int>f(1,1);
        int i=0,j=0,k=0;
        while(--n){//第一个为1已经存在
            long long t=min(f[i]*2,min(f[j]*3,f[k]*5));
            f.push_back(t);
            if(f[i]*2==t){i++;}
            if(f[j]*3==t){j++;}
            if(f[k]*5==t){k++;}
        }
        return f.back();
    }
};