Rrui的Leetcode算法刷題筆記（六）

注：本頁有大量的鎖定題，由於本人非常窮，所以本頁的題非常少。

268. Missing Number

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        
        int k=INT_MAX;
        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]==0)
                continue;
            nums[abs(nums[i])-1]=-abs(nums[abs(nums[i])-1]);
            if(nums[abs(nums[i])-1]==0)
                k=abs(nums[i])-1;
        }
        if(k!=INT_MAX)
            nums[k]=-1;    
        
        for(int i=0;i<nums.size();i++)
            if(nums[i]>=0)
                return i+1;
        return 0;  
    }
};

注：簡單題，如果數字存在的話則對應下標的那個數標爲負數，特殊情況是0，需要特殊考慮。faster than 51.79%。

273. Integer to English Words

注：困難題，。faster than XX%。

274. H-Index/275. H-Index II

class Solution {
public:
    int hIndex(vector<int>& citations) {
         
        if(citations.size()==0)
            return 0;
        
        sort(citations.begin(),citations.end());
        int max=INT_MIN,p=1;
        
        for(int i=citations.size()-1;i>=0;i--)
        {
            if(citations[i]>=p)
                max=p>=max?p:max;
            p++;
        }
        return max==INT_MIN?0:max;
    }
};

注：中等題，可以用二分法解決，當時只想到排序，沒有想到還可以繼續簡化時間。faster than 25.58%。

278. First Bad Version

// Forward declaration of isBadVersion API.
bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        
        long long low=1,high=n,mid;
        
        while(low<=high)
        {
            mid=(low+high)/2;
            if(!isBadVersion(mid))
                low=mid+1;
            else high=mid-1;
        }
        return low;
    }
};

注：簡單題，簡單的考察二分法，這裏需要使用長整型，因爲測試用例太大相加會越界。faster than 100%。

279. Perfect Squares

class Solution {
public:
    int numSquares(int n) {
        
        vector<int> a(n+1,INT_MAX);
        a[0]=1;
        
        for(int i=1;i<=n;i++)
        {
            int k=int(sqrt(i));
            if(k*k==i)
                a[i]=1;
            else
                for(int j=1;j<=i/2;j++)
                    a[i]=min(a[i-j]+a[j],a[i]);
        }
        return a[n];
    }
};

注：中等題，動態規劃題。faster than 2.06%。

282. Expression Add Operators

注：困難題，如果數字存在的話則對應下標的那個數標爲負數，特殊情況是0，需要特殊考慮。faster than 51.79%。

283. Move Zeroes

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        
        int k=0;
        
        for(int i=0;i<nums.size();i++)
            if(nums[i]==0)
            {
                nums.erase(nums.begin()+i);
                i--;
                k++;
            }
        while(k--)
            nums.push_back(0);
        
    }
};

注：簡單題，雙指針法是最優解，我直接刪除添加了。faster than 93.87%。

284. Peeking Iterator

注：中等題，如果數字存在的話則對應下標的那個數標爲負數，特殊情況是0，需要特殊考慮。faster than 51.79%。

287. Find the Duplicate Number

注：中等題，如果數字存在的話則對應下標的那個數標爲負數，特殊情況是0，需要特殊考慮。faster than 51.79%。

289. Game of Life

注：中等題，如果數字存在的話則對應下標的那個數標爲負數，特殊情況是0，需要特殊考慮。faster than 51.79%。

290. Word Pattern

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        unordered_map<char,int> m1;
        unordered_map<string,int> m2;
        istringstream in(str);
        int i = 0;
        for(string word;in>>word;++i){
            if(m1.find(pattern[i])!=m1.end()||m2.find(word)!=m2.end()){
                if(m1[pattern[i]]!=m2[word]){
                    return false;
                }
            }else{
                m1[pattern[i]] = m2[word] = i+1;
            }
        }
        return i==pattern.size();
    }
};

注：簡單題，用倆map即可求解，代碼懶得寫，抄來的。faster than 100.00%。

292. Nim Game

class Solution {
public:
    bool canWinNim(int n) {
        if (n % 4 == 0)
            return false;
        return true;
    }
};

注：簡單題，不解釋，浪費時間。faster than 100.00%。

295. Find Median from Data Stream

https://blog.csdn.net/qq508618087/article/details/51014047

https://blog.csdn.net/u014673347/article/details/50633866

注：困難題，需要用到堆，同時維護大頂堆和小頂堆。faster than XX%。

297. Serialize and Deserialize Binary Tree

注：困難題，需要用到堆，同時維護大頂堆和小頂堆。faster than XX%。

299. Bulls and Cows

class Solution {
public:
    string getHint(string secret, string guess) {
        
        int a=0,b=0;
        map<char,int> c;
        string s;
        
        for(char a:secret)
            c[a]++;
        
        for(int i=0;i<guess.size();i++)
            if(secret[i]==guess[i])
            {
                a++;
                c[secret[i]]--;
            }

        for(int i=0;i<guess.size();i++)
            if(secret[i]!=guess[i]&&c.find(guess[i])!=c.end()&&c[guess[i]]>0)
            {
                b++;
                c[guess[i]]--;
            }
     
        s+=to_string(a)+'A';
        s+=to_string(b)+'B';
        return s;
    }
};

注：中等題，兩編遍歷就好了。faster than 58.73%。

300. Longest Increasing Subsequence

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        
        if(nums.size()==0)
            return 0;
        vector<int> a(nums.size(),1);
        int k=1;
        for(int i=nums.size()-2;i>=0;i--)
        {
            for(int j=i+1;j<nums.size();j++)
            {
                if(nums[j]>nums[i])
                {
                    a[i]=max(a[i],a[j]+1);
                    k=max(a[i],k);
                }    
            }
        }
        return k;
    }
};

注：中等題，我想到的是動態規劃方法，還有一更變態的動態規劃+二分搜索，在內循環直接找第一個大於nums[i]的數，喪心病狂。faster than 58.73%。

306. Additive Number

注：中等題，兩編遍歷就好了。faster than 58.73%。

312. Burst Balloons

注：中等題，兩編遍歷就好了。faster than 58.73%。

313. Super Ugly Number

注：中等題，兩編遍歷就好了。faster than 58.73%。

315. Count of Smaller Numbers After Self

class Solution {
public:     
    vector<int> countSmaller(vector<int>& nums) {
        vector<int> counts(nums.size());
        vector<int> trans;
        if (nums.size() == 0)
            return counts;
        trans.push_back(nums[nums.size() - 1]);
        for (int i = nums.size() - 2; i >= 0; i--) {
            // 這裏二分我們用STL裏的就好了
            auto it = lower_bound(trans.begin(), trans.end(), nums[i]);
            counts[i] = it - trans.begin();
            trans.insert(it, nums[i]);
        }
        return counts;
    }
};

注：困難題，用二分查找法。faster than XX%。

316. Remove Duplicate Letters

注：困難題，如果數字存在的話則對應下標的那個數標爲負數，特殊情況是0，需要特殊考慮。faster than 51.79%。

Rrui的Leetcode算法刷題筆記（七）鏈接如下：

https://blog.csdn.net/Rrui7739/article/details/84073153

279. 完全平方數

class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n + 1, INT_MAX);
        for(int i = 1; i * i <= n; i++)
            dp[i * i] = 1;
        for(int i = 1; i <= n; i++)
            for(int j = 1; j * j < i; j++)
                dp[i] = min(dp[i], dp[i - j * j] + 1);
        return dp[n];
    }
};

287. 尋找重複數

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        if(nums.empty())
            return 0;
        int low = 1, high = nums.size()-1;
        while(low<high)
        {
            int mid = (low+high)/2;//找到（1，n）的中間的數
            int count = 0;
            for(int i=0;i<nums.size();++i)
            {
                if(nums[i] <= mid)//找到數組中比中間的數小的所有數的個數
                    count++;
            }
            if(count <= mid)//如果個數小於中間的數，則重複的數在數組右邊，反之在左邊
                low = mid+1;
            else
                high = mid;
        }
        return low;
    }
};

307. 區域和檢索 - 數組可修改

class NumArray {
public:
    
    vector<int> a;
        
    NumArray(vector<int> nums) {
        a=nums;
    }
    
    void update(int i, int val) {
        a[i]=val;
    }
    
    int sumRange(int i, int j) {
        int sum=0;
        for(int k=i;k<=j;k++)
            sum+=a[k];
        return sum;
    }
};

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * obj.update(i,val);
 * int param_2 = obj.sumRange(i,j);
 */

Rrui的Leetcode算法刷題筆記（六）

Leetcode算法刷題筆記（四）

Leetcode算法刷題筆記（二）

Rrui的Leetcode算法刷題筆記（八）

Rrui的Leetcode算法刷題筆記（六）

人臉檢測與識別：AlexNet人臉檢測

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結