Leetcode(8)-medium2

92, 134, 136, 141, 142, 152, 153,263

92.Reverse Linked List II

Reverse a linked list from position m to n. Do it in-place and in one-pass.

把[m,n]那一段reverse

class Solution {
public:
ListNode* reverseBetween(ListNode* head, int m, int n) {
vector<ListNode*> range(n - m + 1);
ListNode* iter = head;
//找到m位置
for(int i = 1; i < m; ++i)
iter = iter->next;
//复制m-n
for(int i = m, j = 0; i <= n; ++i, ++j)
{
range[j] = iter;
iter = iter->next;
}
//vector swap函数将m、n间反转（值反转）
for(size_t i = 0; i < range.size() / 2; ++i)
swap(range[i]->val, range[range.size() - i - 1]->val);
return head;
}
};

134.Gas Station

有N个加油站点构成一个环状，每个站点i加油量为gas[i]，从站点i到站点i+1需要耗费cost[i]，现要求从哪个站点出发可以成功转一圈回到初始站点，返回该站点，若没有则返回-1；

class Solution {
public:
int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
if (gas.size() == 0 || cost.size() == 0 || gas.size() != cost.size()) return -1;
int total = 0, sum = 0, start = 0;
for (int i = 0; i < gas.size(); ++i){
total += (gas[i] - cost[i]);
if (sum < 0){ //发现油箱空了，从下一个站点尝试
sum = (gas[i] - cost[i]);
start = i;
}
else
sum += (gas[i] - cost[i]);
}
return total < 0 ? -1 : start; //用total判断start 是否是满足要求的解
}
};

/article/6171345.html

136.Single Number

异或

class Solution {
public:
int singleNumber(vector<int>& nums) {
int x=0;
for(int i=0; i<nums.size(); i++){
x = x ^ nums[i];
}
return x;
}
};

141.链表是否有环

双指针，do-while

class Solution {
public:
bool hasCycle(ListNode *head) {
ListNode*slow;
ListNode*fast;
slow=fast=head;
do
{
if(!slow || !fast)  return false;
slow = slow->next;
fast = fast->next;
//此处不要一次走两步
if(fast)
fast = fast->next;
else
return false;
}while(slow != fast);
return true;
}
};

142.Linked List Cycle II

判环一样

如果Slow从环的起始位置，Fast从环的第k个位置开始，最终两个指针会在n-k这个位置相遇（n为环的长度）（f比l多走n-k步）

从相遇点出发再次前进，并计数（追击）可以得到环的长度

class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode*slow;
ListNode*fast;
slow=fast=head;
do
{
if(!slow || !fast)  return NULL;
slow = slow->next;
fast = fast->next;
if(fast)
fast = fast->next;
else
return NULL;
}while(slow != fast);
slow = head;
while(slow!=fast){
slow=slow->next;
fast=fast->next;
}
return slow;
}
};

152.连续子数组最大乘积

与最大和不同，两个负数相乘为正可能为最大，考虑动态规划求解

为了处理数组元素为负的问题，必须将最小乘积也保存起来

max[i] = MaxinThree(a[i], a[i]*max[i-1], a[i]*min[i-1]); //求三者最大

min[ i] = MininThree(a[i], a[i]*max[i-1], a[i]*min[i-1]); //求三者最小

class Solution {
public:
int maxProduct(vector<int>& nums) {
int l=nums.size();
if(l==0) return 0;
if(l==1) return nums[0];

vector<int>max(l);
vector<int>min(l);
max[0] = nums[0];
min[0] = nums[0];
int ssum=nums[0];
for(int i=1;i<l;i++){
max[i] = MaxinThree(nums[i], nums[i]*max[i-1], nums[i]*min[i-1]);    //求三者最大
min[i] = MininThree(nums[i], nums[i]*max[i-1], nums[i]*min[i-1]);    //求三者最小
if(ssum<max[i])
ssum=max[i];
}
return ssum;
}
int MaxinThree(int a, int b, int c)
{
return (((a>b)?a:b)>c) ? (a>b?a:b) : c;
}

int MininThree(int a, int b, int c)
{
return (((a<b)?a:b)<c) ? (a<b?a:b) : c;
}
};

153.Find Minimum in Rotated Sorted Array

使用快排中partion函数，可以在O(n)复杂度下寻找任意第k大的元素；

或者二分查找最小元素（此题中无重复元素）

最笨可以遍历。。。；

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

263.丑数

仅判别

class Solution {
public:
bool isUgly(int num) {
if(num==1) return true;
if(num==0) return false;
while(num%2==0)
num/=2;
while(num%3==0)
num/=3;
while(num%5==0)
num/=5;
return (num==1)?true:false;
}
};