【leetcode】算法题记录(81-90)

搜索旋转排序数组 II

在这里插入图片描述
解题思路,这道题因为之前做过,所以肯定是用二分法来解题。而且排序数组,看到排序也会想到是用二分法来降低时间复杂度。这道题和之前的不一样的地方在于可能包含重复数组,所以这个点是解决这道题的关键。

之前解决的时候是三种情况:

  • 找到则返回true
  • nums[l] < nums[mid],说明前半部分有序,然后根据target来判断是在前面的还是后面的
  • nums[l] > nums[mid],说明后半部分有序,然后根据target来判断是在前面的还是后面的

这道题因为多了一个重复的条件,所以会多出一种情况,即

  • nums[l] == nums[mid],因为这样的话是无法判断前面有序还是后面有序,所以处理时通过l++去除干扰项。

AC代码:

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int l = 0, r = nums.size()-1;
        while(l <= r) {
            int mid = l + (r - l) / 2;
            if (nums[mid] == target) return true;
            if (nums[l] == nums[mid]) {
                l++;
            }
            else if (nums[l] < nums[mid]) {
                if (target >= nums[l] && target < nums[mid]) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
            } else {
                if (target <= nums[r] && target > nums[mid]) {
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
        }
        return false;
    }
};

删除排序链表中的重复元素 II

在这里插入图片描述
解题思路,删除重复的数字比较容易想到的用三个指针操作,第一个指针保存不重复的数字,第二三个指针用于搜索数字,如果第二三个指针数字不相同则把第二个指针保存,若相同继续递增第三个指针,直到和第二个指针数字不相同为止。

AC代码:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head == NULL || head->next == NULL) return head;
        ListNode *pre = new ListNode(-1);
        ListNode *second = head;
        ListNode *res = pre;
        while(second->next != NULL) {
            ListNode *first = second;
            second = second->next;
            //相邻的两个指针值不同,则第一个指针可以被收入
            if(first->val != second -> val) {
                pre->next = first;
                pre = first;
            }else {
                while(second->next != NULL && second->val == first->val) {
                    second = second->next;
                }
            }
            //对最后一个值进行判断
            if(second->next == NULL && second->val != first->val) {
                pre->next = second;
                pre = second;
            }
        }
        pre->next = NULL;
        return res->next;
    }
};

删除排序链表中的重复元素

在这里插入图片描述
和上一道题相比,这道题容易不少,因为这道题可以用双指针就可以解决。但是思路确实差不多的。第一个指针确定数字,第二个指针用于扫描判断下一个数字。

AC代码:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head == NULL || head->next == NULL) return head;
        ListNode* scan = head;
        while(scan->next != NULL) {
            ListNode* pre = scan;
            scan = scan->next;
            while(scan->next != NULL && pre->val == scan->val) {
                scan = scan->next;
            }
            if(pre->val != scan->val) pre->next = scan;
            else pre->next = NULL;
        }
        return head;
    }
};

柱状图中最大的矩形

在这里插入图片描述
乍一看,感觉这道题和之前的最大盛水题目类似,所以想着用双指针,发现双指针无法解决问题,然后想到用动态规划,暴力当然超时。
无奈之下,看题解,大概的意思就是找到每个点的左右边界,而这个左右边界满足的条件是左右两边都必须大于等于这个点,然后找到最大值。

AC代码:

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int n = heights.size();
        vector<int> left(n), right(n, n);
        
        stack<int> mono_stack;
        for (int i = 0; i < n; ++i) {
            while (!mono_stack.empty() && heights[mono_stack.top()] >= heights[i]) {
                right[mono_stack.top()] = i;
                mono_stack.pop();
            }
            left[i] = (mono_stack.empty() ? -1 : mono_stack.top());
            mono_stack.push(i);
        }
        
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans = max(ans, (right[i] - left[i] - 1) * heights[i]);
        }
        return ans;
    }
};

最大矩形

在这里插入图片描述
又是没有解出来的一题,等会儿中午再理一下思路。
解题思路:

状态转移:
heights[i][j]表示点[i][j]的高度,由当前点和heights[i-1][j]共同决定。
matrix[i][j] == 0, heights[i][j] = 0; matrix[i][j] == 1, heights[i][j] = heights[i-1][j] + 1;
dp[i][j][k]表示点[i][j]在高度为k的时候最大面积,由前一个位置决定。
dp[i][j][k] = dp[i][j-1][k] + k;

AC代码:

class Solution {
public:
    int maximalRectangle(vector<vector<char>>& matrix) {
        int n = matrix.size();
		int m = 0;
		if (n > 0) { m = matrix[0].size(); }
		vector<vector<int>> heights(n + 1,vector<int>(m + 1,0));
		vector<vector<vector<int>>> dp(n + 1,vector<vector<int>>(m + 1, vector<int>(n + 1, 0)));
		int ans = 0;
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= m; j++) {
				if (matrix[i-1][j-1] == '0') { continue; }
				heights[i][j] = heights[i-1][j] + 1;
				for (int k = 1; k <= heights[i][j]; k++) {
					dp[i][j][k] = dp[i][j-1][k] + k;
					ans = max(ans, dp[i][j][k]);
				}
			}
		}
		return ans;
    }
};

分隔链表

在这里插入图片描述

解题思路,看了半天题目的意思,要求是小于x的都按照原来的顺序放到前面,大于等于x的顺序不变放到后面。明白要求之后就很清楚的知道如何去解决,定义两个哑结点分别指向小于x的链表和大于等于x的链表。

AC代码:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode *small = new ListNode(-1);
        ListNode *res = new ListNode(-1);
        res -> next = head;
        ListNode *ope = res;
        ListNode *sope = small;
        while(ope != NULL && ope->next != NULL) {
            ListNode* pre = ope;
            ope = ope->next;
            if(ope->val < x) {
                sope->next = ope;
                sope = ope;
                pre->next = ope->next;
                sope->next = NULL;
                ope = pre;
            }
        }
        sope->next = res->next;
        return small->next;
    }
};

扰乱字符串

在这里插入图片描述
解题思路,题目中的第一句话就表明了使用递归。
递归的思路,将给定的s1分成两部分 [0, i),[i, s1.size()-i), 1 < i < s1.size();
那么对应的s2可以是 [0, i),[i, s2.size()-i) 也可以是交换后的 [s2.size-i,s2.size)[0,s2.size()-i)。
需要注意的是,在递归的时候需要提前判断结束,否则会超时

AC代码:

class Solution {
public:
    bool recursive(string s1, string s2) {
        if(s1 == s2) return true;
        //提前结束递归,防止超时
        string t1 = s1, t2 = s2;
        sort(t1.begin(), t1.end());
        sort(t2.begin(), t2.end());
        if(t1 != t2) return false;
        for(int i = 1; i < s1.size(); ++i) {
            bool f1 = recursive(s1.substr(0, i), s2.substr(0, i)) && recursive(s1.substr(i, s1.size() - i), s2.substr(i, s2.size() - i));
            bool f2 = recursive(s1.substr(0, i), s2.substr(s2.size() - i, i)) && recursive(s1.substr(i, s1.size() - i), s2.substr(0, s2.size() - i));
            if(f1 || f2) return true;
        }
        return false;
    }

    bool isScramble(string s1, string s2) {
        if(s1.size() != s2.size()) return false;
        return recursive(s1, s2);
    }
};

合并两个有序数组

在这里插入图片描述

看到这道题,第一反应想到的是有序双链表合并,但是数组和链表不同的是,数组插入需要移动后面所有的位置,显然太麻烦。当然也可以直接调用vector的函数进行插入后排序,但是这样并不是最优解。最好的办法是从数组的后面对比插入,这样可以直接替换就可以了。

AC代码:

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int p = m+n-1;
        for(; n > 0; --n) {
            if(m == 0 || nums2[n-1] >= nums1[m-1]) {
                nums1[p--] = nums2[n-1];
            }else {
                while(m >=1 && nums1[m-1] >= nums2[n-1]) {
                    nums1[p--] = nums1[m-1];
                    --m;
                }
                nums1[p--] = nums2[n-1];
            }
        }
    }
};

格雷编码

在这里插入图片描述

这道题更像一道找规律的题目,当你写出前几位的结果出来之后,可能就会发现规律。然后根据这个规律编码。
规律如下:
在这里插入图片描述

AC代码:

class Solution {
public:
    vector<int> grayCode(int n) {
        vector<int> res = {0};
        if(n == 0) return res;
        for(int i = 0; i < n; ++i) {
            vector<int> tmp = res;
            reverse(tmp.begin(), tmp.end());
            for(auto t : tmp) {
                res.push_back(t + (1 << i));
            }
        }
        return res;
    }
};
展开阅读全文

Python数据分析与挖掘

01-08
92讲视频课+16大项目实战+源码+¥800元课程礼包+讲师社群1V1答疑+社群闭门分享会=99元   为什么学习数据分析?       人工智能、大数据时代有什么技能是可以运用在各种行业的?数据分析就是。       从海量数据中获得别人看不见的信息,创业者可以通过数据分析来优化产品,营销人员可以通过数据分析改进营销策略,产品经理可以通过数据分析洞察用户习惯,金融从业者可以通过数据分析规避投资风险,程序员可以通过数据分析进一步挖掘出数据价值,它和编程一样,本质上也是一个工具,通过数据来对现实事物进行分析和识别的能力。不管你从事什么行业,掌握了数据分析能力,往往在其岗位上更有竞争力。    本课程共包含五大模块: 一、先导篇: 通过分析数据分析师的一天,让学员了解全面了解成为一个数据分析师的所有必修功法,对数据分析师不在迷惑。   二、基础篇: 围绕Python基础语法介绍、数据预处理、数据可视化以及数据分析与挖掘......这些核心技能模块展开,帮助你快速而全面的掌握和了解成为一个数据分析师的所有必修功法。   三、数据采集篇: 通过网络爬虫实战解决数据分析的必经之路:数据从何来的问,讲解常见的爬虫套路并利用三大实战帮助学员扎实数据采集能力,避免没有数据可分析的尴尬。   四、分析工具篇: 讲解数据分析避不开的科学计算库Numpy、数据分析工具Pandas及常见可视化工具Matplotlib。   五、算法篇: 算法是数据分析的精华,课程精选10大算法,包括分类、聚类、预测3大类型,每个算法都从原理和案例两个角度学习,让你不仅能用起来,了解原理,还能知道为什么这么做。
©️2020 CSDN 皮肤主题: 我行我“速” 设计师: Amelia_0503 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值