C++ में लगातार II तक पत्थरों को हिलाना

मान लीजिए कि हम एक अनंत संख्या रेखा पर विचार कर रहे हैं, यहाँ i−th पत्थर की स्थिति सरणी पत्थरों द्वारा दी गई है और पत्थर [i] ith पत्थर की स्थिति का संकेत दे रहा है। एक पत्थर एक समापन बिंदु पत्थर है यदि इसकी सबसे छोटी या सबसे बड़ी स्थिति है। अब प्रत्येक मोड़ में, हम एक समापन बिंदु पत्थर उठाते हैं और इसे एक खाली स्थान पर ले जाते हैं ताकि यह अब समापन बिंदु पत्थर न रहे।

यदि पत्थरों का कहना है, पत्थर =[1,2,5], तो हम समापन बिंदु पत्थर को स्थिति 5 पर नहीं ले जा सकते, क्योंकि इसे किसी भी स्थिति (जैसे 0, या 3) पर ले जाने से भी वह पत्थर एक समापन बिंदु पत्थर के रूप में रहेगा। ।

यह खेल तब रुकेगा जब हम कोई और चाल नहीं चल पाएंगे। तो पत्थर लगातार स्थिति में हैं।

यहां हमें यह पता लगाना है कि खेल कब समाप्त होता है, तो न्यूनतम और अधिकतम चालें क्या होंगी जो हम कर सकते थे? उत्तर एक जोड़ी के रूप में खोजें [min_moves, max_moves]

उदाहरण के लिए, यदि इनपुट [7,3,9] जैसा है, तो परिणाम [1,3]

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

• आकार 2 के एक सरणी उत्तर को परिभाषित करें

• ans[0] :=inf, ans[1] :=−inf and n :=size of a

• सरणी को क्रमबद्ध करें a

• एक्स:=1

• जबकि x

  • x को 1 से बढ़ाएँ

• यदि x, n के समान है, तो,

  • एक जोड़ी लौटाएं {0,0}

• मिनवैल:=0, जे:=1

• प्रारंभ करने के लिए i :=0, जब i

  • curr :=a[i], lastPossible =a[i]

  • अगर लास्ट पॉसिबल> ए [एन -1], तो, लूप से बाहर आएं

  • स्पेसइनबीच :=असत्य

  • अगर j <=i, तो,

    • जे:=मैं + 1

  • जबकि j

    • अगर a[j] - a[j - 1])> 1, तो,

      • स्पेसइनबीच :=सच

    • अगर a[j] - a[j - 1])> 1, तो,

    • j को 1 से बढ़ाएँ

  • आईडीएक्स:=जे - 1

  • अगर n - (idx - i + 1)> 1, तो,

    • स्पेसइनबीच :=सच

• बॉल लेफ्ट:=i, बॉलराइट:=n - (idx + 1)

• minVal :=ballLeft + ballRight + (0 जब spaceInBetween सत्य हो, अन्यथा 1)

• ans[0] :=न्यूनतम minVal ans[0]

• ans[1] :=अधिकतम a[n - 2] - a[0] और a[n - 1] - a[1]) - (n - 2),

• वापसी उत्तर

• मुख्य विधि से कॉल सॉल्व (पत्थर)

उदाहरण

#include <bits/stdc++.h>
using namespace std;
void print_vector(vector<auto> v){
   cout << "[";
   for(int i = 0; i<v.size(); i++){
      cout << v[i] << ", ";
   }
   cout << "]"<<endl;
}
class Solution {
   public:
   vector<int> solve(vector<int> a) {
      vector <int> ans(2);
      ans[0] = INT_MAX;
      ans[1] = INT_MIN;
      int n = a.size();
      sort(a.begin(), a.end());
      int x = 1;
      while(x < n && a[x] - a[x - 1] == 1)
         x ++;
      if(x == n){
         return {0,0};
      }
      int minVal = 0;
      int j = 1;
      for(int i = 0; i < a.size(); i++){
         int curr = a[i];
         int lastPossible = a[i] + n - 1;
         if(lastPossible > a[n - 1])
            break;
         bool spaceInBetween = false;
         if(j <= i)
            j = i + 1;
            while(j < n && a[j] <= lastPossible){
               if((a[j] - a[j - 1]) > 1) {
                  spaceInBetween = true;
               }
               j++;
            }
           int idx = j - 1;
           if(n - (idx - i + 1) > 1)
              spaceInBetween = true;
           int ballLeft = i;
           int ballRight = n - (idx + 1);
           minVal = ballLeft + ballRight + (spaceInBetween? 0 : 1);
           ans[0] = min(minVal, ans[0]);
        }
       ans[1] = max(a[n - 2] - a[0], a[n - 1] - a[1]) - (n -2);
       return ans;
   }
   vector<int> numMovesStonesII(vector<int>& stones) {
      return solve(stones);
   }
};
main(){
   Solution ob;
   vector<int> v1 = {7,3,9};
   print_vector(ob.numMovesStonesII(v1));
}

इनपुट

[7,3,9]

आउटपुट

[1, 3, ]