Leetcode Weekly Contest 130

1017. Convert to Base -2
分析：2进制，每次模5，看最后的末尾数字是不是5或者0

class Solution {
public:
    string baseNeg2(int N) {
        if(N==0) return  "0";
        vector<int>res;
        while(N){
            if(N>0){
                res.push_back(N%(-2));
                N/=(-2);
            }else{
                if(N%(-2)==0){
                    res.push_back(0);
                    N/=(-2);
                }else{
                    int j=N/(-2)+1;
                    res.push_back(N-j*(-2));
                    N=j;
                }
            }
        }
        string ans="";
        for(int i=res.size()-1;i>=0;i--) ans+=res[i]+'0';
        return ans;
    }
};

1018. Binary Prefix Divisible By 5
分析：10进制转化成负数进制，很值得学习的一道题，方法同转化成整数进制一样，只是在当前数为负数，且不能整除的时候，需要加1处理一下

class Solution {
public:
    vector<bool> prefixesDivBy5(vector<int>& A) {
        vector<bool>res;
        int sum=0;
        for(auto v:A){
            sum*=2;
            sum+=v;
            sum%=5;
            if(sum%5==0||sum%10==0){
                res.push_back(true);
            }else{
                res.push_back(false);
            }
        }
        return res;
        
    }
};

1019. Next Greater Node In Linked List
分析：首先把链表翻转，加到一个数组里面，用一个栈来维护在他右边距离他最近的比他大的，方法就是如果栈中没有比他大的数，就把所有元素出栈，只把他压栈。否则找到栈中第一个比他大的数

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* Rev(ListNode* head){
        ListNode* pre=NULL;
        while(head){
            ListNode* tmp=head->next;
            head->next=pre;
            pre=head;
            head=tmp;
        }
        return pre;
    }
    vector<int> nextLargerNodes(ListNode* head) {
        ListNode* tmp=Rev(head);
        vector<int>res;
        while(tmp){
            res.push_back(tmp->val);
            tmp=tmp->next;
        }
        stack<int>s;
        s.push(0);
        vector<int>ans;
        for(int i=0;i<res.size();i++){
            while(!s.empty()&&s.top()<=res[i]) s.pop();
            if(s.empty()){
                ans.push_back(0);
            }else{
                ans.push_back(s.top());
            }
            s.push(res[i]);
        }
        vector<int>t;
        for(int i=ans.size()-1;i>=0;i--){
            t.push_back(ans[i]);
        }
        return t;
    }
};

1020. Number of Enclaves
分析：从边缘为1的位置开始DFS，在连通块内的标记为0，注意judge函数内不要加vector，因为太慢了，会T

class Solution {
public:
    bool judge(int i,int j,int n,int m){
        if(i<0||j<0||i>=n||j>=m) return false;
        return true;
    }
    bool bound(int i,int j,int n,int m){
        if(i==0||j==0||i==n-1||j==m-1)
            return true;
        return false;
    }
    void dfs(int i,int j,int n,int m,vector<vector<int>>&A){
        if(!judge(i,j,n,m)||A[i][j]==0) return;
        A[i][j]=0;
        dfs(i+1,j,n,m,A);
        dfs(i,j+1,n,m,A);
        dfs(i-1,j,n,m,A);
        dfs(i,j-1,n,m,A);
    }
    int numEnclaves(vector<vector<int>>& A) {
        int n=A.size();
        if(n==0) return 0;
        int m=A[0].size();
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(bound(i,j,n,m)&&A[i][j]==1){
                    dfs(i,j,n,m,A);
                }
            }
        }
        int cnt=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(A[i][j]==1) cnt++;
            }
        }
        return cnt;
    }
};