【每日练习】1

最新推荐文章于 2024-03-23 16:33:53 发布

Utotao

最新推荐文章于 2024-03-23 16:33:53 发布

阅读量306

点赞数

CC 4.0 BY-SA版权

分类专栏：每日练习

本文链接：https://blog.youkuaiyun.com/Utotao/article/details/89178305

每日练习专栏收录该内容

14 篇文章

订阅专栏

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

代码部分：

class Solution {
public:
    int lengthOfLongestSubstring(string s){
        set<char > label;
        size_t right = 0,left = 0,res = 0;
        while(right != s.size()){//逐个循环
            if(label.find(s[right]) == label.end()){//no->insert
                label.insert(s[right++]);
                res = max(res,label.size());
            }
            else{//already have
                label.erase(s[left++]);
            }
        }
        return res;
    }
};

思考：如果要求输出最常字符串及其长度应该如何写？

/* 存在多个长度相同最大子字符串，如何同时输出？ */
#include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;

string lengthOfLongestSubstring(string s) {
    string strTemp;
    int flag = 0;
    size_t position = 0;
    vector<string> str;
    set<char> t;
    string::size_type left = 0, right = 0;
    while (right < s.size()) {
        if (t.find(s[right]) == t.end()) {
            t.insert(s[right++]);
            flag = 1;
        }
        else {
            if(flag){
                for(decltype(t.begin()) i = t.begin();i != t.end();i++){
                    strTemp += *i;
                }
                flag = 0;
                str.push_back(strTemp);
            }

            t.erase(s[left++]);
        }
    }
    size_t maxSize = (*(str.begin())).size();
    for(vector<string>::size_type i = 0;i < str.size();i++){
        if(str[i].size() > maxSize){
            maxSize = str[i].size();
            position = i;
        }
    }
    return str[position];
}


int main(){
    string strTemp;
    string str;
    cin >> str;
    strTemp = lengthOfLongestSubstring(str);
    cout << strTemp << endl;
    return 0;
}

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:
nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0
示例 2:
nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

菜鸡的日常：

double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
    double midNumber;
    vector<int > num;
    for(auto i : nums1)
        num.push_back(i);
    for(auto i : nums2)
        num.push_back(i);
    sort(num.begin(),num.end());
    auto beg = num.begin(),end = num.end(),mid = num.begin() +(end - beg)/2;
    if(num.size() % 2 == 0)//偶数个元素
    {
        double num1 = *(prev(mid));
        double num2 = *((vector<int>::iterator)(prev(mid) + 1));
        midNumber = (num1 + num2)/2;
    }
    else{
        midNumber = *mid;
    }
    return midNumber;
}

时间复杂度计算：

参考：【1】（数据结构）十分钟搞定时间复杂度（算法的时间复杂度）

什么是时间复杂度：

算法的时间复杂度，用来度量算法的运行时间，记作: T(n) = O(f(n))。它表示随着输入大小n 的增大，算法执行需要的时间的增长速度可以用 f(n) 来描述。这样用大写O（）来体现算法时间复杂度的记法，我们称之为大O记法。

如何通过T(n)推导时间复杂度？

我们知道常数项对函数的增长速度影响并不大，所以当 T(n) = c，c 为一个常数的时候，我们说这个算法的时间复杂度为 O(1)；如果 T(n) 不等于一个常数项时，直接将常数项省略。
我们知道高次项对于函数的增长速度的影响是最大的。n^3 的增长速度是远超 n^2 的，同时 n^2 的增长速度是远超 n 的。同时因为要求的精度不高，所以我们直接忽略低此项。
因为函数的阶数对函数的增长速度的影响是最显著的，所以我们忽略与最高阶相乘的常数。

综合起来：如果一个算法的执行次数是 T(n)，那么只保留最高次项，同时忽略最高项的系数后得到函数 f(n)，此时算法的时间复杂度就是 O(f(n))。

由执行次数 T(n) 得到时间复杂度并不困难，很多时候困难的是从算法通过分析和数学运算得到 T(n)。

时间复杂度分析的基本策略是：从内向外分析，从最深层开始分析。如果遇到函数调用，要深入函数进行分析。