LeetCode笔记（list：next-＞next = 新地址**）

21 - 63 - 445.

21. 合并两个有序链表**

卡了一下，注意是 next->next = 新地址，而不是 next

// 22.18
// 22.32
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == nullptr) return l2;
        if(l2 == nullptr) return l1;

        ListNode *head = new ListNode(0);
        ListNode *next = head;
        while(l2 && l1) {
            if(l1->val < l2->val) {
                next->next = l1;
                l1 = l1->next;
            }
            else {
                next->next = l2;
                l2 = l2->next;
                
            }
            next = next->next;
        }
        if(l1 == nullptr) next->next = l2;
        if(l2 == nullptr) next->next = l1;

        return head->next;
    }
};

445. 两数相加 II

1. 笨方法：用string存储两个list中的数据，然后相加，再把答案放进新的list中
2. 最优解：逆序，要想到栈（我就没有想到。。。）

// 22.35
// 23.16
// 用string
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if(l1 == nullptr || l1->val == 0) return l2;
        if(l2 == nullptr || l2->val == 0) return l1;
        
        string a, b;
        while(l1) {
            a = (char)(l1->val + '0') + a;
            l1 = l1->next;
        }
        while(l2) {
            b = (char)(l2->val + '0') + b;
            l2 = l2->next;
        }
        int adder = 0;
        string str;
        while(a.size() < b.size()) a =  a + '0';
        while(b.size() < a.size()) b =  b + '0';
        for(int i = 0; i < a.size() && i < b.size(); i++) {
            char tmp = a[i] + b[i] + adder - '0';
            adder = 0;
            if(tmp > '9') {
                adder = 1;
                tmp -= 10;
            }
            str = tmp + str;
            //cout << str << endl;
        }

        if(adder) str = '1' + str;
        ListNode *head = new ListNode(0);
        ListNode *next = head;
        for(auto ch : str) {
            next->next = new ListNode(ch - '0');
            next = next->next;
        }

        return head->next; 
    }
};

//用栈
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if(l1 == nullptr || l1->val == 0) return l2;
        if(l2 == nullptr || l2->val == 0) return l1;
        
        stack<int> a, b;
        while(l1) {
            a.push(l1->val);
            l1 = l1->next;
        }
        while(l2) {
            b.push(l2->val);
            l2 = l2->next;
        }

        ListNode *head = new ListNode(0);
        ListNode *next = head;
        int adder = 0;
        while(!a.empty() || !b.empty()) { // 这里可以直接加上 "|| !adder"
            int t1 = 0, t2 = 0;
            if(!a.empty()) {
                t1 = a.top();
                a.pop();
            }
            if(!b.empty()) {
                t2 = b.top();
                b.pop();
            }
            int sum = t1 + t2 + adder;
            adder = 0;
            if(sum > 9) {
                sum -= 10;
                adder = 1;
            }
            next = new ListNode(sum);
            next->next = head->next;
            head->next = next;
        }
        if(adder) {
            next = new ListNode(1);
            next->next = head->next;
            head->next = next;
        }

        return head->next;
    }
};

63. 不同路径 II

简单！

// 23.35
// 23.45
class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& grid) {
        if(grid.empty()) return 0;

        //vector<vector<int>> dp = grid;
        grid[0][0] = (grid[0][0])? 0 : 1;
        for(int i = 1; i < grid.size(); i++) {
            grid[i][0] = (grid[i][0])? 0 : grid[i - 1][0];
        }
        for(int i = 1; i < grid[0].size(); i++) {
            grid[0][i] = (grid[0][i])? 0 : grid[0][i - 1];
        }

        for(int i = 1; i < grid.size(); i++) {
            for(int k = 1; k < grid[0].size(); k++) {
                grid[i][k] = (grid[i][k])? 0 : grid[i - 1][k] + grid[i][k - 1];
            }
        }

        return grid[grid.size() - 1][grid[0].size() - 1];
    }
};