Leetcode个人训练答案-指针

• 206反转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        //递归
        /*ListNode* ans;
        if(head == nullptr) return head;
        if(head->next == nullptr) return head;
        ans = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return ans;*/
        //双指针
        ListNode* temp;
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while(cur != nullptr) {
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

仔细琢磨一下递归，ans指向的值始终都是链表的尾结点。

• 203移除链表元素

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

注释掉的是灰的方法，我觉得写的很清晰~

• LCP剧情触发事件

class Solution {
public:
    vector<int> getTriggerTime(vector<vector<int>>& increase, vector<vector<int>>& requirements) {
        int raws = increase.size() + 1;
        int cols = increase[0].size();
        int an = requirements.size();
        vector<vector<int>> sum(raws,vector(cols,0));
        for(int i = 1;i < raws;++i) {
            for(int j = 0;j < cols;++j) {
                sum[i][j] = sum[i-1][j] + increase[i-1][j];
            }
        }
        vector<int> ans;
        for(auto v:requirements) {
            int l = 0;
            int r = increase.size();
            while(l < r) {
                int m = (l + r) / 2;
                if(sum[m][0] >= v[0] && sum[m][1] >= v[1] && sum[m][2] >= v[2])
                    r = m;
                else l = m + 1;
            }
            if(sum[r][0] >= v[0] && sum[r][1] >= v[1] && sum[r][2] >= v[2])
            ans.push_back(r);
            else ans.push_back(-1);
        }
        return ans;
        /*vector<int> ans(an,-1);
        int day = 0;
        int i = 0;
        int j = 0;
        for(day = 0;day < an;++day) {//i是行数
            for(i = 0;i < raws;++i) {//day是天数
                int flag = 0;
                for(j = 0;j < cols;++j) {//j是列数
                    if(requirements[day][j] > sum[i][j]) {
                        break;
                    }
                    else ++flag;
                }
                if(flag == cols && ans[day] == -1) {
                    ans[day] = i;
                    break;
                }
            }
        }
    }
};
/*class Solution {
public:
    int biFind(const vector<vector<int>>& increase,const vector<vector<int>>& requirements,int  RowNum, int  target)
    {
        if(target == 0 ) return 0;
        int high = increase.size()-1, low = 0;
        while (low <= high){
		    int mid = low + (high - low) / 2;
		    if (increase[mid][RowNum] >= target && increase[mid-1][RowNum] < target){
                return mid;
            }
            if(increase[mid][RowNum] >= target){
                high = mid;
            }
            else{
                low = mid+1;
            }
	    }
        return -1;
    }

    vector<int> getTriggerTime(vector<vector<int>>& increase, vector<vector<int>>& requirements) {
        int resourceNum = increase.size();
        int requireNum = requirements.size();
        for(int i = 1; i<resourceNum; i++)
        {
            increase[i][0] += increase[i-1][0];
            increase[i][1] += increase[i-1][1];
            increase[i][2] += increase[i-1][2];
        }
        increase.insert(increase.begin(),vector<int>{0,0,0});
        vector<int> res(requireNum,-1);
        for(int i = 0 ; i < requireNum; i++){
            int index_0 = biFind(increase, requirements, 0, requirements[i][0]);
            int index_1 = biFind(increase, requirements, 1, requirements[i][1]);
            int index_2 = biFind(increase, requirements, 2, requirements[i][2]);
            if(index_0 <0 || index_1 <0 || index_2 < 0) continue;
            res[i] = max(index_0, max(index_1,index_2));
        }
        return res;

    }
};*/

题解的答案，我的答案和灰的答案。