LeetCode | 740. Delete and Earn

Given an array nums of integers, you can perform operations on the array.

In each operation, you pick any nums[i] and delete it to earn nums[i] points. After, you must delete every element equal to nums[i] - 1 or nums[i] + 1.

You start with 0 points. Return the maximum number of points you can earn by applying such operations.

Example 1:

Input: nums = [3, 4, 2]
Output: 6
Explanation: 
Delete 4 to earn 4 points, consequently 3 is also deleted.
Then, delete 2 to earn 2 points. 6 total points are earned.

Example 2:

Input: nums = [2, 2, 3, 3, 3, 4]
Output: 9
Explanation: 
Delete 3 to earn 3 points, deleting both 2's and the 4.
Then, delete 3 again to earn 3 points, and 3 again to earn 3 points.
9 total points are earned.

Note:

• The length of nums is at most 20000.
• Each element nums[i] is an integer in the range [1, 10000].

  简单来说就是不断的取一个数，将数组中比这个数大一和小一的数全部删除，看最后得到的数的和，毫无疑问，这题使用DP来解决，不过我看网上的标准答案有BUG，题目并没有说数组中的数是连续的，而网上的标准答案默认了数组中的数是连续的，和容易就能举出不连续数组的反例，

  通过这道题我收获了几个技巧，其一是以后在解决这样的题目的时候，对于同一个数多次出现的题，可以设定一个数组，num[n]用来记录n出现的次数，或者是n出现次数的和，

  以后在解dp的题目的时候可能dp[n]，当n大于某个数的时候dp才有效，因此可以先把dp[1-n]先自己求出，当做特殊情况处理，然后在用公式解决n之后的值的dp

  Sort(a.begin(),a.end())这个是对vector使用sort的技巧

   

  class Solution {

      #include <algorithm>

  public:

      int deleteAndEarn(vector<int>&nums) {

        sort(nums.begin(), nums.end());

       

        vector <int> numIndex; int j = 0;

        vector <int> numCount;

        int dp[20000];

        if (nums.size() == 0) return 0;

   

        for (int i = 0; i < nums.size(); i++)

        {

              if (nums[i] != nums[j]) {

                    numIndex.push_back(j);

                    numCount.push_back(nums[j] *(i - j));

                    j = i;

              }

        }

        numIndex.push_back(j);

        numCount.push_back(nums[j] * (nums.size() -j));

   

        dp[0] = numCount[0];

        if (numCount.size() == 1) return dp[0];

   

        if (abs(nums[numIndex[1]] -nums[numIndex[0]]) == 1)

        {

              dp[1] = max(numCount[0],numCount[1]);

        }

        else

        {

              dp[1] =numCount[0]+numCount[1];

        }

        if (numCount.size() == 2) return dp[1];

        if (abs(nums[numIndex[2]] -nums[numIndex[1]]) == 1)

        {

              if (abs(nums[numIndex[1]] -nums[numIndex[0]]) == 1)

              {

                    dp[2] = max(numCount[0] +numCount[2],numCount[1]);

              }

              else

              {

                    dp[2] = max(numCount[0] + numCount[1],numCount[0]+ numCount[2]);

              }

        }

        else

        {

              if (abs(nums[numIndex[1]] -nums[numIndex[0]]) == 1)

              {

                    dp[2] = max(numCount[0] +numCount[2], numCount[1] + numCount[2]);

              }

              else

              {

                    dp[2] = numCount[0] +numCount[1] + numCount[2];

              }

        }

   

        if (numCount.size() == 3) return dp[2];

   

        int maxNum = max(max(dp[0], dp[1]),dp[2]);

   

        for (int i = 3; i < numIndex.size();i++)

        {

              if (abs(nums[numIndex[i]] -nums[numIndex[i - 1]]) == 1)

              {

                    dp[i] = max(dp[i - 3] +numCount[i], dp[i - 2] + numCount[i]);

              }

              else

              {

                    if (abs(nums[numIndex[i - 1]]- nums[numIndex[i - 2]]) == 1)

                    {

                         dp[i] = max(dp[i - 2] +numCount[i], dp[i - 1] + numCount[i]);

                    }

                    else

                    {

                         dp[i] = dp[i - 1] +numCount[i];

                    }

              }

             

              if (dp[i] > maxNum) maxNum =dp[i];

        }

        return maxNum;

      }

      int max(int a,int b)

      {

          return a<b?b:a;

      }

  };