सी ++ में कुछ चरणों के बाद एक ही स्थान पर रहने के तरीकों की संख्या

मान लीजिए कि arrLen आकार की एक सरणी है, और हमारे पास उस सरणी में अनुक्रमणिका 0 पर एक सूचक भी है। प्रत्येक चरण में, हम 1 स्थिति को बाईं ओर, 1 स्थिति को दाईं ओर ले जा सकते हैं या उसी स्थान पर रह सकते हैं।

अब मान लीजिए कि हमारे पास दो पूर्णांक चरण हैं और arrLen, हमें ऐसे तरीकों की संख्या ज्ञात करनी है कि सूचक बिल्कुल चरणों के बाद भी सूचकांक 0 पर है। अगर उत्तर बहुत बड़ा है तो इसे मॉड्यूलो 10^9 + 7 लौटाएं।

इसलिए, यदि इनपुट चरण =3, arrLen =2 जैसा है, तो आउटपुट 4 होगा, क्योंकि 3 चरणों के बाद इंडेक्स 0 पर रहने के 4 अलग-अलग तरीके हैं। ये हैं [राइट, लेफ्ट, स्टे], [स्टे, राइट, लेफ्ट], [राइट, स्टे, लेफ्ट], [स्टे, स्टे, स्टे]।

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

• मी :=1e9 + 7

• फ़ंक्शन ऐड () को परिभाषित करें, इसमें a, b,

  . लगेगा

• वापसी (एक मॉड एम + बी मॉड एम) मॉड एम

• एक 2डी सरणी डीपी परिभाषित करें

• एक फ़ंक्शन हल करें () को परिभाषित करें, इसमें n, x लगेगा, इसे 0 से प्रारंभ करें,

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

  • जब पॉज़ 0 के समान हो तो सही लौटें

• अगर dp[pos, n] -1 के बराबर नहीं है, तो -

  • वापसी डीपी [स्थिति, एन]

• उत्तर:=0

• अगर पॉज़> 0, तो

  • उत्तर:=जोड़ें (उत्तर, हल करें (एन, एक्स -1, पॉज़ -1))

• अगर स्थिति

  • उत्तर:=जोड़ें (उत्तर, हल करें (एन, एक्स -1, पॉज़ + 1))

• उत्तर:=जोड़ें (उत्तर, हल करें (एन, एक्स -1, पॉज़))

• डीपी [स्थिति, एन]:=उत्तर

• वापसी उत्तर

• मुख्य विधि से निम्न कार्य करें -

• x :=न्यूनतम आगमन और चरण / 2 + 1

• dp :=2 x (x + 1) आकार के एक 2D सरणी को परिभाषित करें, इसे 0 से भरें

• डीपी [0, 0] :=1

• n :=गिरफ्तारी

• इनिशियलाइज़ i :=1 के लिए, जब i <=स्टेप्स, अपडेट (i से 1 की वृद्धि), करें -

  • इनिशियलाइज़ j :=0 के लिए, जब j <कम से कम arrLen और स्टेप/2 + 1, अपडेट करें (j को 1 से बढ़ाएँ), करें -

    • x :=(i-1) मॉड 2

    • y :=i mod 2

    • डीपी [वाई, जे]:=डीपी [एक्स, जे]

    • अगर j - 1>=0, तो -

      • dp[y, j] :=add(dp[y, j], dp[x, j-1])

    • यदि j + 1

      • dp[y, j] :=add(dp[y, j], dp[x, j + 1])

• वापसी डीपी [चरण मोड 2, 0]

आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -

उदाहरण

#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
const int MOD = 1e9 + 7;
lli add(lli a, lli b){
   return (a % MOD + b % MOD) % MOD;
}
class Solution {
   public:
   vector<vector<int> > dp;
   int solve(int n, int x, int pos = 0){
      if (x == 0) {
         return pos == 0;
      }
      if (dp[pos][n] != -1)
      return dp[pos][n];
      int ans = 0;
      if (pos > 0)
      ans = add(ans, solve(n, x - 1, pos - 1));
      if (pos < n - 1)
      ans = add(ans, solve(n, x - 1, pos + 1));
      ans = add(ans, solve(n, x - 1, pos));
      dp[pos][n] = ans;
      return ans;
   }
   int numWays(int steps, int arrLen){
      int x = min(arrLen, steps / 2 + 1);
      this->dp = vector<vector<int> >(2, vector<int>(x + 1, 0));
      dp[0][0] = 1;
      int n = arrLen;
      for (int i = 1; i <= steps; i++) {
         for (int j = 0; j < min(arrLen, steps / 2 + 1); j++) {
            int x = (i - 1) % 2;
            int y = i % 2;
            dp[y][j] = dp[x][j];
            if (j - 1 >= 0)
            dp[y][j] = add(dp[y][j], dp[x][j - 1]);
            if (j + 1 < n)
            dp[y][j] = add(dp[y][j], dp[x][j + 1]);
         }
      }
      return dp[steps % 2][0];
   }
};
main(){
   Solution ob;
   cout << (ob.numWays(3,2));
}

इनपुट

3, 2

आउटपुट

4