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 是否是满足要求的解
    }
};

http://www.cnblogs.com/felixfang/p/3814463.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;  
    }
};