Leetcode 1751. El número máximo de reuniones a las que se puede asistir II (DÍA 71) ---- Período de aprendizaje de programación dinámica (la próxima semana comenzará el conteo alto, tres cuartos por semana)

Titulo original

---

Implementación de código (primer tiempo de espera del pincel n ^ 3 complejidad de tiempo)

bool cmp(const vector<int>& a,const vector<int>& b)
{
    
    
    if(a[1] < b[1] || a[1] == b[1] && a[2] < b[2]) return true;
    else   return false;
}

class Solution {
    
    
public:
    int maxValue(vector<vector<int>>& events, int k) {
    
    
        sort(events.begin(),events.end(),cmp);
        int esize = events.size(),ret = -1;
        int endsize = (events.back())[1];
        vector<vector<int>> dp(k+1,vector<int>(endsize+1,0));
        for(int i=1;i<=k;i++)
        {
    
    
            for(int j=0;j<esize;j++)
            {
    
    
                for(int k=0;k<=events[j][0]-1;k++)
                    dp[i][events[j][1]] = max(dp[i-1][k] + events[j][2],dp[i][events[j][1]]);
                ret = max(ret,dp[i][events[j][1]]);
            }
        }
        return ret;
    }
};

---

Implementación del código (la versión optimizada n ^ 3 aún se agota el tiempo de espera n ^ 2 * el registro no se agota)

bool cmp(const vector<int>& a,const vector<int>& b)
{
    
    
    if(a[1] < b[1] || a[1] == b[1] && a[2] < b[2]) return true;
    else   return false;
}

class Solution {
    
    
public:
    int maxValue(vector<vector<int>>& events, int k) {
    
    
        sort(events.begin(),events.end(),cmp);
        int esize = events.size(),ret = -1;
        vector<vector<int>> dp(k+1,vector<int>(esize+1,0));
        for(int i=1;i<=k;i++)
        {
    
    
            for(int j=0;j<esize;j++)
            {
    
    
                dp[i][j] = fmax(events[j][2],dp[i][j]);
                for(int k=0;k<j;k++)
                {
    
    
                    if(events[k][1] <= events[j][0]-1)
                        dp[i][j] = fmax(dp[i][j],dp[i-1][k] + events[j][2]);
                    else break; 
                }
                ret = max(ret,dp[i][j]);
            }
        }
        return ret;
    }
};

---

Implementación de código (aceleración de dos puntos de la resolución de problemas n ^ 2 * logn de otras personas)

class Solution {
    
    
public:
    static bool cmp(const vector<int>& x, const vector<int>& y) {
    
    
        return x[1] < y[1];
    }
    int maxValue(vector<vector<int>>& events, int k) {
    
    
        int n = events.size();
        sort(events.begin(), events.end(), cmp);
        
        vector<vector<int>> dp(n, vector<int>(k + 1, INT_MIN));
        dp[0][0] = 0;
        dp[0][1] = events[0][2];
        
        for (int i = 1; i < n; i++) {
    
    
            // 参加会议 i，此时需要二分查找
            int l = 0, r = i;
            while (r - l > 1) {
    
    
                int mid = (l + r) / 2;
                if (events[mid][1] >= events[i][0]) {
    
    
                    r = mid;
                } else {
    
    
                    l = mid;
                }
            }
            if (events[l][1] < events[i][0]) {
    
    
                for (int j = 1; j <= k; j++) {
    
    
                    dp[i][j] = max(dp[i][j], dp[l][j-1] + events[i][2]);
                }
            } else {
    
    
                dp[i][1] = max(dp[i][1], events[i][2]);
            }
            
            // 不参加会议 i
            for (int j = 0; j <= k; j++) {
    
    
                dp[i][j] = max(dp[i][j], dp[i-1][j]);
            }
        }
        
        int ret = 0;
        for (int i = 0; i <= k; i++) {
    
    
            ret = max(ret, dp[n-1][i]);
        }
        return ret;
    }
};