2021-11-04

869. 重新排序得到 2 的幂

暴力打表

class Solution {
public:
	bool check(int power,int num){
		int p[10],n[10];
		memset(p,0,sizeof(p));
		memset(n,0,sizeof(n));
		while(power){
			p[power%10]++;
			power/=10;
		}
		while(num){
			n[num%10]++;
			num/=10;
		}
		for(int i=0;i<10;++i){
			if(p[i]!=n[i]){
				return 0;
			}
		}
		return 1;
	}
    bool reorderedPowerOf2(int n) {
		for(int i=0;i<31;++i){
			if(check(pow(2,i),n)){
				return 1;
			}
		}
		return 0;
    }
};

dfs回溯

class Solution {
public:
    vector<int> used;
	bool isPowerOfTwo(int n) {
        if(n<=0) return 0;
        return (n & (n - 1)) == 0;
    }
    bool backTrack(string& nums,int id,int cur){
    	if(id==nums.size()){
    		return isPowerOfTwo(cur);
		}
		for(int i=0;i<nums.size();++i){
			if((cur==0&&nums[i]=='0')||used[i]==1||(i>0&&used[i-1]==0&&nums[i]==nums[i-1])){
				continue;				
			}
			used[i]=1;
			if(backTrack(nums,id+1,cur*10+nums[i]-'0')){
				return 1;
			}
			used[i]=0;
		}
		return 0;
	}
    bool reorderedPowerOf2(int n) {
		string nums=to_string(n);
		sort(nums.begin(),nums.end());
		used.resize(nums.size());
		return backTrack(nums,0,0);
    }
};

91. 解码方法

class Solution {
public:
    int numDecodings(string s) {
		if(s[0]=='0') return 0;
		int n=s.size();
		vector<int> dp(n+1,0);
		dp[0]=1,dp[1]=1;
		for(int i=2;i<=n;++i){
			if(s[i-1]=='0'){
				if(s[i-2]=='1'||s[i-2]=='2'){
					dp[i]=dp[i-2];//唯一被译码，情况不变
				}
				else{
					return 0;
				}
			}
			else {
                if(s[i-2]=='1' || (s[i-2]=='2'&&s[i-1]>='1'&&s[i-1]<='6')){
				    dp[i]=dp[i-1]+dp[i-2];//合并译码	
			    }
			    else dp[i]=dp[i-1];//s[i-2]为其他数不译码，情况不变
		    }
        }
		return dp[n];
    }
};

413. 等差数列划分

dp

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& A) {
		int n=A.size();
		int sum=0;
		vector<int> dp(n,0);
		for(int i=2;i<n;++i){
			if(A[i-1]-A[i-2]==A[i]-A[i-1]){
				dp[i]=dp[i-1]+1;
				sum+=dp[i];
			}
		}
		return sum;
	}
};

双指针

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& A) {
        const int N = A.size();
        int res = 0;
        for (int i = 0; i < N - 2; i++) {
            int d = A[i + 1] - A[i];
            for (int j = i + 1; j < N - 1; j++) {
                if (A[j + 1] - A[j] == d) 
                    res ++;
                else
                    break;
            }
        }
        return res;
    }
};

42. 接雨水

class Solution {
public:
    int trap(vector<int>& height) {
		int ans=0;
		int l=0,r=height.size()-1;
		int lmax=0,rmax=0;
		while(l<r){
			lmax=max(lmax,height[l]);
			rmax=max(rmax,height[r]);
			if(height[l]<height[r]){
				ans+=lmax-height[l];
				++l;
			}
			else{
				ans+=rmax-height[r];
				--r;
			}
		}
		return ans;
    }
};

260. 只出现一次的数字 III

class Solution {
public:
    vector<int> singleNumber(vector<int>& nums) {
        unordered_map<int,int> map;
        vector<int> ans;
        for(int num:nums){
            map[num]++;
        }
        for(auto i:map){
            if(i.second==1){
                ans.push_back(i.first);
            }
        }
        return ans;
    }
};

1143. 最长公共子序列

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
		int n=text1.size();
		int m=text2.size();
		vector<vector<int>> dp(n+1,vector<int>(m+1));
		for(int i=0;i<=n;++i){
			dp[i][0]=0;
		}
		for(int j=0;j<=m;++j){
			dp[0][j]=0;
		}
		for(int i=1;i<=n;++i){
			for(int j=1;j<=m;++j){
				if(text1[i-1]==text2[j-1]){
					dp[i][j]=dp[i-1][j-1]+1;
				}
				else{
					dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
				}
			}
		}
		return dp[n][m];
    }
};

300. 最长递增子序列

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
		int n=nums.size();
		if(n==0) return 0;
		vector<int> dp(n,0);
		for(int i=0;i<n;++i){
			dp[i]=1;
			for(int j=0;j<i;++j){
				if(nums[j]<nums[i]){
					dp[i]=max(dp[i],dp[j]+1);
				}
			}
		} 
		return *max_element(dp.begin(),dp.end());
    }
};

674. 最长连续递增序列

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        int n=nums.size();
        //if(n==0) return 0;
        int res=1;
        int count=1;
        for(int i=0;i<n-1;++i){
            if(nums[i]<nums[i+1]){
                    count++;
                }
                else count=1;
            if(count>res) res=count;
        }
        return res;
    }
};

两个字符串的删除操作

class Solution {
public:
    int minDistance(string word1, string word2) {
        int n=word1.size();
		int m=word2.size();
		vector<vector<int>> dp(n+1,vector<int>(m+1));
		for(int i=0;i<=n;++i){
			dp[i][0]=i;
		}
		for(int j=0;j<=m;++j){
			dp[0][j]=j;
		}
		for(int i=1;i<=n;++i){
			for(int j=1;j<=m;++j){
				if(word1[i-1]==word2[j-1]){
					dp[i][j]=dp[i-1][j-1];
				}
				else{
					dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1);
				}
			}
		}
		return dp[n][m];
    }
};