力扣周赛338场第二题问一下哪里错了

Question

1. 质数减法运算
   通过的用户数3007
   尝试过的用户数3552
   用户总通过次数3096
   用户总提交次数9275
   题目难度Medium
   给你一个下标从 0 开始的整数数组 nums ，数组长度为 n 。

你可以执行无限次下述运算：

选择一个之前未选过的下标 i ，并选择一个 严格小于 nums[i] 的质数 p ，从 nums[i] 中减去 p 。
如果你能通过上述运算使得 nums 成为严格递增数组，则返回 true ；否则返回 false 。

严格递增数组 中的每个元素都严格大于其前面的元素。

class Solution {
public:
    bool primeSubOperation(vector<int>& nums) {
       int flag=1;
       for(int i=0;i<nums.size()-1;i++) 
       {
           if(nums[i]>=nums[i+1])
           {
               flag=0;
               break;
           }
       }
      if(flag==1)
      {
          return true;
      }
     for(int i=0;i<nums.size();i++)
     {
         stack<int>x;
         if(nums[i]<=2)
         {
             if(i==0)
             {
                 x.push(nums[i]);
                 continue;
             }
            else if(i==1)
            {
                if(nums[i]==2&&nums[0]==1)x.push(nums[i]);
                else return false;
            }
           else
              return false;
         }
          else
          {
              vector<int>isprime;
             for(int j=2;j<nums[i];j++)
             {
                 if(j==2||j==3)isprime.push_back(j);
                 else
                 {
                     int symbol=0;
                     for(int k=2;k<=j/k+1;k++)
                     {
                         if(j%k==0)
                         {
                             symbol=1;
                             break;
                         }
                     }
                      if(symbol==0)isprime.push_back(j);
                 }
              }
             int flag2=0;
             if(i==0)
             {
             x.push(nums[i]-isprime[isprime.size()-1]);
            continue;
             }
           for(int t=isprime.size()-1;t>=0;t--)
           {
               if(nums[i]-isprime[t]>x.top())
               {
                   x.push(nums[i]-isprime[t]);
                  flag2=1;
                  break;
               }
           }
          if(flag2==0&&nums[i]<=x.top())return false;
          if(flag2==0&&nums[i]>x.top())
          {
              x.push(nums[i]);
             continue;
          }
          flag2=0;
          }
     }
     return true;
    }
};

Answer 1

引用GPT：你的代码的思路是对的，但是可能存在一些细节错误。以下是一些可能出错的点：

1 在遍历isprime数组时，你的循环范围应该是从 2 到 nums[i]-1 ，而不是从 2 到 nums[i]。

2 在第二次遍历nums数组时，如果当前 nums[i] 小于等于栈顶元素，应该直接返回 false，而不是入栈。

3 在第二次遍历nums数组时，如果 nums[i] 小于等于 2，需要特判处理。如果 nums[0] 不等于 1，或者 nums[1] 不等于 2，则应该直接返回 false。

下面是修改后的代码，你可以尝试一下：

class Solution {
public:
    bool primeSubOperation(vector<int>& nums) {
        int n = nums.size();
        stack<int> st;
        st.push(nums[0]);
        for (int i = 1; i < n; i++) {
            if (nums[i] <= st.top()) {
                return false;
            }
            if (nums[i] <= 2) {
                if ((i == 1 && nums[0] == 1) || i > 1) {
                    return false;
                }
            } else {
                vector<int> isprime;
                for (int j = 2; j < nums[i]; j++) {
                    int flag = 0;
                    for (int k = 2; k * k <= j; k++) {
                        if (j % k == 0) {
                            flag = 1;
                            break;
                        }
                    }
                    if (flag == 0) {
                        isprime.push_back(j);
                    }
                }
                int flag2 = 0;
                for (int j = isprime.size() - 1; j >= 0; j--) {
                    if (nums[i] - isprime[j] > st.top()) {
                        st.push(nums[i] - isprime[j]);
                        flag2 = 1;
                        break;
                    }
                }
                if (flag2 == 0) {
                    return false;
                }
            }
        }
        return true;
    }
};