LeetCode 个人解答记录(1-5)

LeetCode 个人解答记录(1-5)

有待改进，本文章记录解题答案，以便日后查看以及改进

1. Two Sum

   本题采用暴力求解法：

   Runtime: 64 ms, faster than 40.98% of C++ online submissions for Two Sum.

   vector<int> twoSum(vector<int>& nums, int target) {
       int n=nums.size();
       vector<int> result(2);
       for(int i=0;i<n;i++){
           int currentnum=nums[i];
           result[0]=i;
           for(int j=i+1;j<n;j++){
               if((currentnum+nums[j])==target){
                   result[1]=j;
                   return result;
               }
           }
       }
   }
   

   借助Map实现优化，map的KV为值以及值所对应的位置

   Runtime: 8 ms, faster than 70.70% of C++ online submissions for Two Sum.

   vector<int> twoSum(vector<int>& nums, int target) {
       int n=nums.size();
       map<int,int> numsMap;
       vector<int> result;
       for(int i=0;i<n;i++){
           numsMap[nums[i]]=i;
       }
       for(int i=0;i<n;i++){
           int res=target-nums[i];
           if(numsMap.find(res)!=numsMap.end()&&numsMap[res]!=i){
               result.push_back(i);
               result.push_back(numsMap[res]);
               return result;
           }
       }
   }
   

2. Add Two Numbers

   代码不够简洁，逻辑应该有地方可以合并,但是这样写速度很快

   Runtime: 28 ms, faster than 98.46% of C++ online submissions for Add Two

   ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
       ListNode* root =new ListNode(0); 
       ListNode* currentNode=root;
       int forward=0;
       while(l1!=NULL&&l2!=NULL){
           int current=l1->val+l2->val;
           currentNode->val=(forward+current)%10;
           forward=(forward+current-(forward+current)%10)/10;
           l1=l1->next;
           l2=l2->next;
           if(l1||l2){
               ListNode* nextNode=new ListNode(0);
               currentNode->next=nextNode;
               currentNode=nextNode;
           }    
       }
       
       while(l1!=NULL){
           int current=l1->val;
           currentNode->val=(forward+current)%10;
           forward=(forward+current-(forward+current)%10)/10;
           l1=l1->next;
           if(l1){
               ListNode* nextNode=new ListNode(0);
               currentNode->next=nextNode;
               currentNode=nextNode;
           }
       }
       
       while(l2!=NULL){
           int current=l2->val;
           currentNode->val=(forward+current)%10;
           forward=(forward+current-(forward+current)%10)/10;
           l2=l2->next;
           if(l2){
               ListNode* nextNode=new ListNode(0);
               currentNode->next=nextNode;
               currentNode=nextNode;
           }
       }
     
       if(forward!=0){
           ListNode* nextNode=new ListNode(forward);
           currentNode->next=nextNode;
           currentNode=nextNode;
       }
       
       return root;
   }
   

3. Longest Substring Without Repeating Characters

   采用Sliding window法，并且用map记录各个字母第一次出现所在位置来优化

   Runtime: 24 ms, faster than 63.56% of C++ online submissions for Longest Substring Without Repeating Characters

   int lengthOfLongestSubstring(string s) {
       map<char,int> mymap;
       int ans=0;
       int m=s.length();
       for(int i=0,j=0;j<m;j++){
           if(mymap.find(s[j])!= mymap.end()){
               i=max(mymap[s[j]],i);
           }
           ans=max(ans,j-i+1);
           mymap[s[j]]=j+1;
       }
       return ans;
   }
   

4. Median of Two Sorted Arrays

   找两个有序数组的中位数，时间复杂度$O(log(m+n))$，之前腾讯面试问到，但是当时不会，这个解题思路还是很值得总结以及应用的 。

   思路：

   

   在保证左右两堆数量是一样的情况下二分搜索切割A的方法，使得左边最大的小于右边最小的

   Runtime: 52 ms, faster than 32.31% of C++ online submissions for Median of Two Sorted Arrays.

   double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
       int m=nums1.size();
       int n=nums2.size();
       if(m>n){
           int tmp=m; m=n; n=tmp;
           vector<int> temp=nums2;
           nums2=nums1;
           nums1=temp;
       }
       int iMin=0;
       int iMax=m;
       int i,j=0;
       while(iMin<=iMax){
           i=(iMin+iMax)/2;
           j=(m+n+1)/2-i;
           if(i<iMax&&nums2[j-1]>nums1[i]){
               iMin=i+1;
           }else if(i>iMin&&nums1[i-1]>nums2[j]){
               iMax=i-1;
           }else{
               int maxLeft=0;
               if(i==0){
                   maxLeft=nums2[j-1];
               }else if(j==0){
                   maxLeft=nums1[i-1];
               }else{
                   maxLeft=max(nums1[i-1],nums2[j-1]);
               }
               if((m+n)%2==1){
                   return maxLeft;
               }
               int minRight=0;
               if(i==m){
                   minRight=nums2[j];
               }else if(j==n){
                   minRight=nums1[i];
               }else{
                   minRight=min(nums1[i],nums2[j]);
               }
               cout<<maxLeft;
               cout<<minRight;
               double result=(maxLeft+minRight)/2.0;
               return result;
           }
       }
       return 0;
   }
   
   

5. Longest Palindromic Substring

   动态规划，区间DP

   Runtime: 76 ms, faster than 38.20% of C++ online submissions for Longest Palindromic Substring.

   string longestPalindrome(string s) {
       int n=s.length();
       
       int dp[1001][1001]={0};
       int result=0;
       int start=0;
       if(n>0){result=1;}
       for(int i=0;i<n;i++){
           dp[i][i]=1;
           if(s[i]==s[i+1]&&i+1<n){
               dp[i][i+1]=1;
               if(result<2){
                   result=2;
                   start=i;
               }
           }
           
       }
   
       for(int k=3;k<=n;k++){
           for(int i=0,j=i+k-1;j<n;i++,j++){
               if(dp[i+1][j-1]==1&&s[i]==s[j]){
                   dp[i][j]=1;
                   if(result<(j-i+1)){
                       result=j-i+1;
                       start=i;
                   }
                   
               }
           }
       }
   
       return s.substr(start,result);
   }