算法题2020
关于算法的一些总结
- 做题时保持清醒的头脑。保持平静的内心。
- 对于数组和链表，善于利用双指针解决问题。双指针不行就排序后双指针迭代。
- 对于二叉树的按层遍历，考虑利用队列解决问题。
- 首先考虑的是边界条件而不是普适条件。
- 能用迭代就别用递归，例如爬楼梯问题，当n大于45时，递归效率远远不如迭代，一个运行时间大于10s，一个1s以内。
- 动态规划题目记得灵活分析。
- 对于大数相加，超过int或者long类型上限的，可以参考用链表实现的两数相加。
- 对于链表，获取其长度对于搜索链表中的元素很有帮助。例如相交链表问题。
- 求最小的k个数时维护一个大小为k的大顶堆，当比较第i个数小于堆顶，则弹出堆顶，并压入第i个数。求最大的k个数维护一个大小为k的小顶堆，原理与前面相同。
- 对于存在路径选择的题目，合理利用队列和栈的特性解决问题，例如岛屿数量。 系统方法栈（递归）也是栈。
- 对于循环中需要用到之前状态的问题，也要善于利用队列。例如回溯问题。
- 对于求数组中第k大元素的类似问题，构建一个大小为k的小顶堆（而不是大小为数组长度的小顶堆）。
- 若要频繁获取一个数组中第k大的元素，但是数组又经常增删数据。那么维护一个大小是k的小顶堆，原理同上。
- 关于动态规划。一般是求最值。例如最多的路径数，最少的钱币数，最大的子序列。对于这种问题。要先想清楚什么是起始条件，或者说怎么开始滚雪球。比如跳楼梯，1格楼梯肯定只有1种跳法。比如凑硬币，1块钱只能有一种凑法，n块钱有[(n-1)块钱的最少凑法+1]种凑法。比如求最大子序列，当数组长度为1时，子序列肯定是1，当长度为2时，满足条件子序列才为2。当长度为n时，子序列为1+满足条件的(n-m)的最大子序列。
旋转图像
思路：
1 2 3
4 5 6
7 8 9
从最外圈往最内圈依次移动。
对于每一圈，每四个数字为一组，例如（0，0），（2，0），（2，2），（0，2），它们之间相互替换。具体表现为，当横坐标x为0时，可以分为两组，第一组从（0，0）开始依次顺时针90度替换，第二组从（0，1）开始顺时针九十度替换。
也就是说对于最外圈，1，3，9，7顺时针替换，2，6，8，4顺时针替换，内圈5不用替换。
class Solution {
public:
void rotate(vector<vector<int>>& matrix) {
int size = matrix.size();
int layer = size/2;
for(int i = 0; i < layer; i++){//有多少层
for(int j = 0; j < size - 2 * i - 1; j++){//每一层做几次变换
int temp = matrix[i + j][size - 1 - i];//先拿出（2，0）
matrix[i + j][size - 1 - i] = matrix[i][j + i];//将（0，0）旋转90度移动到（2，0）
matrix[i][j + i] = matrix[size - 1 - j - i][i];
matrix[size - 1 - j - i][i] = matrix[size - 1 - i][size - 1 - j - i];
matrix[size - 1 - i][size - 1 - j - i] = temp;
}
}
}
};
字符串中的第一个唯一字符
思路：
小写字母一共26个，则声明一个长度为26的整型数组。
遍历字符串，数组中每个下标s[ i ] - ‘a’ 对应的值代表a-z出现的次数。
再次遍历字符串，访问数组中对应字母出现的次数决定返回值。
class Solution {
public:
int firstUniqChar(string s) {
int array[26] = {0};
for(int i = 0;i < s.size();i++){
array[s[i] - 'a']++;
}
for(int i = 0;i < s.size();i++){
if(array[s[i] - 'a'] == 1){
return i;
}
}
return -1;
}
};
环形链表
思路：
转换成一快一慢辆车在环形跑道上行驶的相遇问题。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
#include<map>
class Solution {
public:
bool hasCycle(ListNode *head) {
if(NULL == head){
return false;
}
ListNode* fast = head->next;
ListNode* slow = head;
while(fast){
slow = slow->next;//不判断空指针因为只要fast不为空则slow永不为空
if(NULL!=fast->next){
fast = fast->next->next;
}else{
fast = fast->next;
}
if(fast == slow){
return true;
}
}
return false;
}
};
验证二叉搜索树
思路：通过递归的方式遍历每一个节点，同时每一次左拐（递归左子树）产生一个最大值条件（即左子树所有值都应小于它），每次右拐产生一个最小值，所有右子树的值都应大于它。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isValidBST(TreeNode* root) {
return isValidBST(root, LONG_MAX, LONG_MIN);
}
bool isValidBST(TreeNode* root, long max, long min) {
if(!root){//递归结束条件
return true;
}
//每次搜索子树的时候更新约束条件以及搜索树成立的判断条件
return isValidBST(root->left, root->val, min)&&isValidBST(root->right, max, root->val)&&max>root->val&&root->val>min;
}
};
对称二叉树
思路：将二叉树拆分成左右两个二叉树，left的左子树和right的右子树比较，递归即可。
考虑如何递归时，应该思考递归发生的条件，本题明显是两个二叉树的比较过程，因此一个参数的方法无法胜任递归，需要重载。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if(!root){
return true;
}else{
return isSymmetric(root->left, root->right);
}
}
bool isSymmetric(TreeNode* left, TreeNode* right) {
if(!left&&!right){
return true;
}else if(left&&right){
return (left->val == right->val)&&isSymmetric(left->left, right->right)&&isSymmetric(left->right, right->left);
}else{
return false;
}
}
};
二叉树的层次遍历
思路：利用队列！！！！本题是队列的经典应用场景，切记切记。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
#include<queue>
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> result;
if(NULL==root){
return result;
}
queue<TreeNode*> q;
q.push(root);
while(!q.empty()){
vector<int> value;
int size = q.size();
for(int i = 0;i < size;i++){//循环是为了符合题目的输出规范
TreeNode* node = q.front();
value.push_back(node->val);
if(NULL!=node->left){
q.push(node->left);
}
if(NULL!=node->right){
q.push(node->right);
}
q.pop();
}
result.push_back(value);
}
return result;
}
};
爬楼梯
思路：每次有两种选择，当楼梯只有1阶时，有1种选择，当楼梯有2阶时，有两种选择（1，2或2，1）。当楼梯有3阶时，有：最后一阶爬两步，前面选择数量的和 + 最后一阶爬一步，前面选择数量的和。即
nums[i - 1] + nums[i - 2];
class Solution {
public:
int climbStairs(int n) {
if(n == 1){
return 1;
}
if(n == 2){
return 2;
}
int *nums = new int[n+1];
nums[0] = 0;
nums[1] = 1;
nums[2] = 2;
for(int i = 3;i < n+1;i++){
nums[i] = nums[i - 1] + nums[i - 2];
}
return nums[n];
}
};
最大子序和
思路：动态规划，应该从数组尾部开始，从最后一个元素往前累加，例如：最后n个元素和为-1，则必然不可能产生比前面更大的和，因此可以不用考虑后n个元素。若最后n个元素和大于0，则有往后累加的必要。
class Solution {
public:
int maxSubArray(vector<int>& nums) {
if(nums.size()<1)
return INT_MIN;
int result = nums[0];
int totalLast = 0;
for(int i = nums.size()-1; i >= 0; i--){
totalLast = totalLast + nums[i];
if(totalLast < 0){//后n个元素的和<0
if(totalLast > result){//判断负数中的最大值
result = totalLast;
}
totalLast = 0;//则舍弃后面的元素
}else{
if(totalLast > result)
result = totalLast;
}
}
return result;
}
};
打家劫舍
思路：记得保存前一次的最大值。比如偷了下标为 0，2两家的和最大，但发现下标为3的钱比下标为2的钱多，此时要获取上一次（也即除开下标为2，之前获得的最大金钱）。相当于退还下标为2的金钱，否则会报警。
class Solution {
public:
int rob(vector<int>& nums) {
int result = 0;
int exSum = 0;
bool canTake = true;
for(int i = 0; i < nums.size(); i++){
if(canTake){
exSum = result;
result+= nums[i];
canTake = !canTake;
}else{//如果本次应该跳过
if(nums[i]+exSum > result){//但发现本次钱更多
int temp = result;
result = exSum + nums[i];
exSum = temp;
canTake = false;
}else{
canTake = true;
}
}
}
return result;
}
};
颠倒二进制位
思路：先设result为0，然后在循环里让目标值和1做‘位与’运算，result向左位移，目标值向右位移。
class Solution {
public:
uint32_t reverseBits(uint32_t n) {
uint32_t result = 0;
for(int i =0;i<32;i++){
result = result<<1;
result+= n&1;
n = n>>1;
cout<<bitset<32>(result)<<endl;
}
return result;
}
};
有效的括号
思路：利用栈，按顺序入栈字符，当出现 ‘)’，‘}’，’]’ 时则栈顶的字符必定与其对应，出栈然后继续循环，否则就不是有效的括号。这道题要注意边界条件，比如当循环完成但是栈中仍有元素，说明有不匹配的字符，返回false。或者当栈里面没有元素时试图入栈 ‘)’，‘}’，’]’ 。
#include<stack>
class Solution {
public:
bool isValid(string s) {
stack<char> sta;
for(int i = 0; i < s.size(); i++){
if('(' - s[i] == 0||'[' - s[i] == 0||'{' - s[i] == 0){
sta.push(s[i]);
}else{
if(sta.size() < 1){
return false;
}
char temp = sta.top();
if(s[i] == ')'&&temp == '('||s[i] == ']'&&temp == '['||s[i] == '}'&&temp == '{'){
sta.pop();
}else{
return false;
}
}
}
if(sta.size()>0){
return false;
}
return true;
}
};
缺失数字
思路：等差数列前n项和减去数组和即为缺失的数字。
class Solution {
public:
int missingNumber(vector<int>& nums) {
int size = nums.size() + 1;
int sum = (size*(size - 1))/2;
int total = 0;
for(int i = 0; i < nums.size(); i++){
total+=nums[i];
}
return sum-total;
}
};
三数之和
思路：先排序，然后遍历数组。首先确定一个负数nums[i]，设定两个游标分别从数组两侧往中间遍历，若发现三数和为0则加入结果数组中。
本题难点在于去掉重复的结果。
#include<algorithm>
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> result;
sort(nums.begin(), nums.end());
for(int i = 0; i < nums.size(); i++){
cout<<nums[i]<<endl;
}
for(int i = 0; i < nums.size(); i++){
if(i>0&&nums[i - 1] == nums[i]) continue;
int l = i+1;
int r = nums.size() - 1;
while(l < r){
if(nums[i]+nums[l]+nums[r]<0){
l++;
}else if(nums[i]+nums[l]+nums[r]>0){
r--;
}else{
result.push_back({nums[i], nums[l], nums[r]});
l++;
r--;
while(l<nums.size()&&nums[l-1] == nums[l]){//如果发现相同的数字，游标向前移动，因为已经纳入结果中了。
l++;
}
while(r>=0&&nums[r+1] == nums[r]){
r--;
}
}
}
}
return result;
}
};
无重复字符的最长子串
思路：利用双指针对数组进行迭代。然后利用长度为128的数组来存储出现过的字符（ASCII共128个，有效字符不足128个）。当发现重复字符，左指针移至最近的重复字符处，右指针归位至左指针处，数组清空，重新计算长度。因为考虑到以下情况：abcdbef，当判断到第二个字符’b’时，其后面“cd”依然是最长字符中的有效字符。利用固定长度的数组而不是unordered_set。其实两者都有随机访问的功能，但是后者有扩容行为，导致性能下降。
class Solution {
public:
int lengthOfLongestSubstring(string s) {
int result = 0;
int *chars = new int[128]();
int l = 0;
int r = 0;
while(r < s.size()){
if(chars[s[r]] == 0){//判断是否重复字符
chars[s[r]] = 1;
r++;
if(r - l > result){
result = r - l;
}
}else{
resetArray(chars, 128);
while(s[l]!=s[r]){
l++;
}
l++;
r = l;
}
}
delete []chars;
return result;
}
void resetArray(int *arr, int size){
for(int i = 0; i < size; i++){
arr[i] = 0;
}
}
};
最长回文子串
思路：遍历字符串，找到疑似回文串，即：当第i个字符等于i-1或i-2个字符时，利用两个游标向左向右同时扫描，当不等时，则找到当前最长回文串。遍历完即得到最大回文子串。还有一个特殊情况需要处理，即连续相等的字符可以看作一个字符。
class Solution {
public:
string longestPalindrome(string s) {
string result = "";
for(int i = 0; i < s.size(); i++){
if(i == 0){
result.push_back(s[i]);
}else{
int l = 0;
int r = 0;
if(s[i - 1] == s[i]){//对应类似 abccba这种情况
l = i - 1;
r = i;
while(r+1<s.size()){//处理连续相等的字符
if(s[r+1] == s[r]){
r++;
}else{
break;
}
}
}else if(i > 1&&s[i - 2] == s[i]){//对应类似abcdcba这种情况
l = i - 2;
r = i;
}else{
continue;
}
while(l - 1>=0&&r<s.size()){
if(s[l - 1] == s[r + 1]){
l--;
r++;
}else{
break;
}
}
if(r - l + 1>result.size()){//判断当前找到的是否为最大子串。
result = s.substr(l, r - l + 1);
}
}
}
return result;
}
};
相交链表
思路：两个链表一长一短，在长的链表中找到和短链表头节点对应的节点，然后依次比较，若节点地址相同，则说明相交。相当于把两个链表拉直，然后切去多余的部分，剩下的元素一一比较是否相同，若相同的相交。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
if(NULL == headA||NULL == headB){
return NULL;
}
int sizeA = 0;
int sizeB = 0;
ListNode *tempA = headA;
ListNode *tempB = headB;
while(NULL!=tempA||NULL!=tempB){//获取两个链表的长度。
if(NULL!=tempA){
sizeA++;
tempA = tempA->next;
}
if(NULL!=tempB){
sizeB++;
tempB = tempB->next;
}
}
if(sizeA>sizeB){//找到长的链表，并获取短链表对应位置的节点。
tempA = headA;
tempB = headB;
for(int i = 0; i < sizeA-sizeB; i++){
tempA = tempA->next;
}
}else{
tempA = headB;
tempB = headA;
for(int i = 0; i < sizeB-sizeA; i++){
tempA = tempA->next;
}
}
while(NULL!=tempA){
if(tempA == tempB){
return tempA;
}else{
tempA = tempA->next;
tempB = tempB->next;
}
}
return NULL;
}
};
二叉树中序遍历
思路：递归时先递归左子树。迭代时应该利用栈。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> vec;
if(NULL == root){
return vec;
}
return inorderTraversal2(root, vec);
}
vector<int> inorderTraversal2(TreeNode* root, vector<int>& vec) {
if(NULL == root){
return vec;
}
inorderTraversal2(root->left, vec);
vec.push_back(root->val);
inorderTraversal2(root->right, vec);
return vec;
}
};
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
// 1. 栈后法。即先入栈，再访问。
// 2. 中序遍历，左臂入栈法。
vector<int> res;
stack<TreeNode*> path;
while(root) {
path.push(root);
root = root->left;
}
while(!path.empty()) {
auto node = path.top();
path.pop();
res.push_back(node->val);
// 每 pop 一个节点，将其右子树做**左臂入栈**操作。
node = node->right;
while (node) {
path.push(node);
node = node->left;
}
}
return res;
}
};
二叉搜索树第k小的元素之进阶
原题思路：遍历二叉树取第k个元素。
进阶：如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 k 小的值，你将如何优化 kthSmallest 函数？
看了答案：维护个小顶堆和大顶堆，大顶堆堆顶元素是第k小。每次修改二叉树，也去修改大顶堆和小顶堆。这样查找的时候每次取大顶堆堆顶元素就行了。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
#include<stack>
class Solution {
public:
int kthSmallest(TreeNode* root, int k) {
stack<TreeNode*> stack;
while(root){
stack.push(root);
root = root->left;
}
int c = 0;
while(stack.size()>0){
TreeNode* node = stack.top();
stack.pop();
c++;
if(c == k){
return node->val;
}
node = node->right;
while(node){
stack.push(node);
node = node->left;
}
}
return 0;
}
};
数组中的第K个最大元素
思路：建一个长度是k的小顶堆，然后从k开始遍历数组，若nums[i]大于堆顶，则替换之，最后堆中为最大的前k个元素，并且堆顶是第k个最大元素。
不科学，自己写的小顶堆远远慢于标准库。
#include<queue>
class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
if(nums.size() == 0){
return -1;
}
vector<int> copy(nums.begin(),nums.begin()+k);
priority_queue<int, vector<int>, greater<int> > q;
for(int i = 0; i < k; i++){
q.push(nums[i]);
}
//minHeap(copy, copy.size());
for(int i = k; i < nums.size(); i++){
if(nums[i]>q.top()){
q.pop();
q.push(nums[i]);
//copy[0] = nums[i];
//minHeap(copy, copy.size());
}
}
return q.top();
}
void minHeap(vector<int>& nums, int len){
for(int i = len/2-1;i>=0;i--){
if(2*i+1<len&&nums[2*i+1]<nums[i]){
int temp = nums[i];
nums[i] = nums[2*i+1];
nums[2*i+1] = temp;
}
if(2*(2*i+1)+1<len&&nums[2*(2*i+1)+1]<nums[2*i+1]||2*(2*i+1)+2<len&&nums[2*(2*i+1)+2]<nums[2*i+1]){
minHeap(nums, len);
}
if(2*i+2<len&&nums[2*i+2]<nums[i]){
int temp = nums[i];
nums[i] = nums[2*i+2];
nums[2*i+2] = temp;
}
if(2*(2*i+2)+1<len&&nums[2*(2*i+2)+1]<nums[2*i+2]||2*(2*i+2)+2<len&&nums[2*(2*i+2)+2]<nums[2*i+2]){
minHeap(nums, len);
}
}
}
};
搜索二维矩阵2
思路：若二维数组左下角的数大于target，则该行都大于target，若二维数组左下角数小于target，则该列都小于target。
注意分析这种大小关系。
class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
if(matrix.size()==0){
return false;
}else if(matrix[0].size()==0){
return false;
}else if(matrix[0][0]>target||matrix[matrix.size()-1][matrix[0].size()-1]<target){
return false;
}
bool result = searchMatrix(matrix, target, matrix.size()-1, 0);
return result;
}
bool searchMatrix(vector<vector<int>>& matrix, int target,int x, int y) {
if(x<0||y>matrix[0].size()-1){
return false;
}
if(matrix[x][y]==target){
return true;
}else if(matrix[x][y]>target){
return searchMatrix(matrix, target, x-1, y);
}else if(matrix[x][y]<target){
return searchMatrix(matrix, target, x, y+1);
}
return false;
}
};
零钱兑换
思路：要凑成的金额是固定的，如果能确定 n - m的最少钱币组成，那么n的最小组成为n-m+m。例如有纸币1，3，5要组成11块，则其应为10块的最小组成加上1块。
class Solution {
public:
int coinChange(vector<int>& coins, int amount) {
sort(coins.begin(), coins.end());
if(amount == 0){
return 0;
}
if(coins.size() == 0){
return -1;
}
int arr[amount+1];//背包，存储1-amount的所有最小纸币数目。
std::fill(arr, arr+amount+1, INT_MAX);
for(int i = 0; i < coins.size(); i++){//每一趟能确定当前纸币能组成的所有最小方案。
for(int j = coins[i]; j <= amount; j++){
if(j == 0)
continue;
if(j == coins[i]){
arr[j] = 1;
}else if(arr[j - coins[i]] != INT_MAX){
arr[j] = std::min(arr[j], arr[j - coins[i]]+1);
}
}
}
if(arr[amount] == INT_MAX)
return -1;
return arr[amount];
}
};
最长上升子序列
思路：要善于归纳，本题重点在于如何一步一步构造最大背包。对于本题来说，怎么样才能确定遍历数组的同时下标每增加1获得的子序列最大？当下标是0的时候，毫无疑问，子序列长度是1。当下标是1的时候，要满足nums[0]<nums[1]则子序列长度是2，否则长度是1。这样背包就出来了。当下标是3时，若满足nums[2]>nums[1]，则最大子序列为前一个下标的最大子序列+1。
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if(nums.size()==0)
return 0;
if(nums.size()==1)
return 1;
int length = 1;
int a[nums.size()];
for(int i = nums.size() - 1; i >= 0; i--){
a[i] = 1;
for(int j = i+1; j<nums.size(); j++){//每一趟都能确保当前下标为i的子序列为最大。
if(nums[j]>nums[i]&&a[j]+1>a[i]){
a[i] = a[j]+1;
if(a[i]>length)
length = a[i];
}
}
}
return length;
}
};
阶乘后的零
思路：算乘法因子里5的个数。本题对于数学不好的人极不友好。
class Solution {
public:
int trailingZeroes(int n) {
int result = 0;
while(n>=5){
result+=n/5;
n/=5;
}
return result;
}
};
两整数之和
思路：两数的异或可以得到相加之和，按位与在左移可以得到进位。
class Solution {
public:
int getSum(int a, int b) {
if(b == 0)
return a;
int sum = a^b;
int carry = (unsigned int)(a&b)<<1;
return this->getSum(sum, carry);
}
};
多数元素
思路：摩尔投票法
/*class Solution {
public:
int majorityElement(vector<int>& nums) {
if(nums.size() == 0){
return 0;
}
unordered_map<int, int> map;
for(int i = 0; i < nums.size(); i++){
unordered_map<int, int>::iterator iter = map.find(nums[i]);
if(iter == map.end()){
map.insert(pair<int, int>(nums[i], 1));
}else{
iter->second++;
if(iter->second>nums.size()/2)
return iter->first;
}
}
return nums[0];
}
};*/
class Solution {
public:
int majorityElement(vector<int>& nums) {
if(nums.size() == 0)
return 0;
int count = 1;
int cur = nums[0];
for(int i = 1; i < nums.size(); i++){
if(nums[i] == cur){
count++;
}else if(nums[i] != cur && count>0){
count--;
}else if(nums[i] != cur && count==0){
cur = nums[i];
count++;
}
}
return cur;
}
};
乘积最大子序列
思路：原始思路还是动态规划，声明一个和序列等长的数组，然后确保数组每个元素为该元素下标对应序列的前n项最大乘积。
怎么确保前n项乘积最大？滑动窗口，窗口则为最近的两个负数的下标。遇到零要重新计算下标。
class Solution {
public:
int maxProduct(vector<int>& nums) {
if(nums.size()==0)
return 0;
int result = nums[0];
int a[nums.size()] = {nums[0]};
int ind1 = -1;//窗口左边界
int ind2 = -1;//窗口右边界
for(int i = 0; i < nums.size(); i++){
if(nums[i] == 0){
ind1 = -1;
ind2 = -1;
a[i] = 0;
}else{
if(i == 0){
a[i] = nums[i];
if(nums[i]<0){
ind1 = i;
}
}else{
if(nums[i]>0){
a[i] = a[i-1]>0?a[i-1]*nums[i]:nums[i];
}else{
if(ind1<0){
ind1 = i;
a[i] = nums[i];
continue;
}else if(ind2<0){
ind2 = i;
}else{
ind1 = ind2;
ind2 = i;
}
int t = 1;
for(int j = ind1; j <= ind2;j++){
t*=nums[j];
}
if(ind1-1>=0&&a[ind1-1]>0)
t*=a[ind1-1];
a[i] = t;
}
}
}
if(a[i]>result)
result = a[i];
}
//print(a,nums.size());
return result;
}
void print(int a[], int size){
for(int i = 0; i < size; i++){
cout<<a[i]<<",";
}
cout<<endl;
}
};
448
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
