2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
विषयवस्तुसारणी
गतिशीलप्रोग्रामिंगस्य अवगमने समस्याः प्रवर्तन्ते : १.
विश्लेषणम् : (हिंसकः पश्चात्तापः) २.
Dfs कोड उदाहरणम् : (अन्वेषणम्)
क्रूरबल पुनरावृत्तिद्वारा उत्पन्नः पुनरावृत्तिवृक्षः : १.
कोड उदाहरणम् : (गतिशील प्रोग्रामिंग, लघुतम उपसमस्यायाः आरम्भः)
निष्पादनप्रक्रिया (गतिशीलप्रोग्रामिंग) : १.
विश्लेषणम् : (गतिशील प्रोग्रामिंग) २.
डायनामिक प्रोग्रामिंग् इति किम्, डायनामिक प्रोग्रामिंग् इत्यनेन काः समस्याः साधनरूपेण समाधानं कर्तुं शक्यन्ते, डायनामिक प्रोग्रामिंग् इत्यस्य वर्गीकरणं, विशिष्टानां समस्यानां वर्गीकरणं च यत् विशिष्टवर्गीकरणैः समाधानं कर्तुं शक्यते
इदं महत्त्वपूर्णं एल्गोरिदम् प्रतिमानं भवति यत् समस्यां लघु उपसमस्यानां श्रृङ्खलायां विघटयति तथा च उपसमस्यासमाधानं संग्रह्य पुनः पुनः गणनां परिहरति, अतः समयदक्षतायां महतीं सुधारं भवति
सोपानं आरोहणस्य प्रकरणस्य माध्यमेन एषा समस्या प्रवर्तते यत् कुलम् n सोपानं युक्तं सोपानं दत्तं चेत् भवनस्य शिखरं प्रति आरोहणार्थं कति विकल्पाः सन्ति?
अस्य प्रश्नस्य लक्ष्यं समाधानसङ्ख्यां अन्वेष्टुम् अस्ति,वयं पश्चात्तापं कृत्वा सर्वाणि सम्भावनानि सम्पूर्णतया क्षीणं कर्तुं विचारयितुं शक्नुमः . विशेषतः, सोपानं आरोहणं बहुगोलचयनप्रक्रियारूपेण कल्पयन्तु: भूमौ आरभ्य, प्रत्येकं गोलं एकं वा द्वौ वा सोपानौ चयनं कृत्वा, प्रत्येकं सोपानशिखरं प्राप्य विकल्पसङ्ख्यायां १ योजयित्वा, विकल्पानां संख्यां वर्धयितुं च यदा त्वं सोपानस्य शिखरं प्राप्नोषि।
- # python代码示例
- def backrack(choices,state,n,res) :
- if state == n :
- res[0] += 1
- for choice in choices :
- if state + choice > n :
- continue
- backrack(choices,state+choice,n,res)
- def climbing_stairs_backrack(n) :
- choices = [1,2]
- state = 0
- res = [0]
- backrack(choices,state,n,res)
- return res[0]
- n = int(input())
- print(climbing_stairs_backrack(n))
- // c++代码示例
- void backrack(vector<int> &choices, int state, int n, vector<int> &res)
- {
- if (state == n )
- {
- res[0]++ ;
- }
- for (auto &choice : choices)
- {
- if (state + choice > n)
- {
- continue ;
- }
- backrack(choices, state + choice, n, res)
- }
- }
-
- int climbingStairsBackrack(int n)
- {
- vector<int> choices = {1 , 2 } ;
- int state = 0 ;
- vector<int> res = [0] ;
- backrack(choices, state, n, res) ;
- return res[0] ;
- }
पश्चात्ताप-एल्गोरिदम् सामान्यतया समस्यां स्पष्टतया न विच्छिन्दति, परन्तु समस्यां निर्णय-पदार्थानाम् एकां श्रृङ्खलारूपेण व्यवहरति, तथा च अनुमान-विज्ञानस्य, छंटाई-द्वारा च सर्वेषां सम्भाव्यसमाधानानाम् अन्वेषणं करोति
समस्याविघटनस्य दृष्ट्या अस्य प्रश्नस्य विश्लेषणं कर्तुं प्रयत्नः कर्तुं शक्नुमः। कल्पयतु यत् i-तमस्तरं प्रति आरोहणार्थं dp[i] समाधानाः सन्ति, तर्हि dp[i] मूलसमस्या अस्ति, तस्य उपसमस्याः च सन्ति:
दप[इ-१],दप[इ-२],दप[१],दप[२] ।
यतो हि वयं प्रत्येकस्मिन् गोले केवलं १ वा २ सोपानानि एव उपरि गन्तुं शक्नुमः, यदा वयं i-तमे सोपानं तिष्ठामः तदा पूर्वपरिक्रमे केवलं i-१ वा i-२ सोपानेषु एव स्थातुं शक्नुमः अन्येषु शब्देषु वयं केवलं i-1th अथवा i-2th स्तरात् i-th स्तरं प्रति गन्तुं शक्नुमः।
अस्मात् वयं महत्त्वपूर्णं अनुमानं कर्तुं शक्नुमः यत् i-1-स्तरं प्रति आरोहितानां योजनानां संख्या प्लस् i-2-स्तरं प्रति आरोहितानां योजनानां संख्या i-पर्यन्तं आरोहितानां योजनानां संख्यायाः तुल्यम् अस्ति -थ स्तर। सूत्रं यथा---
dp[i] = dp[i-1] + dp[i-2] ।
भवनारोहणसमस्यायां पुनरावर्तनीयः सम्बन्धः अस्ति, उपसमस्यानां समाधानं निर्माय मूलसमस्यायाः समाधानं कर्तुं शक्यते इति तात्पर्यम्
- # python 代码示例
- def dfs(i : int) -> int :
- if i == 1 or i == 2 :
- return i
- count = dfs(i - 1) + dfs(i - 2)
- return count
- def climbing_stairs_dfs(n : int) -> int :
- retunr dfs(n)
- // c++ 代码示例
- int dfs(int i)
- {
- if (i == 1 || i == 2)
- {
- return i ;
- }
- int count = dfs(i - 1) + dfs(i - 2);
- return count ;
- }
- int climbingStairsDFS(int n)
- {
- retunr dfs(n) ;
- }
पुनरावर्तनीयवृक्षे उपर्युक्तस्य द्वितीयकसमस्यायाः समाधानार्थं स्मृतिसन्धानपद्धत्या पुनः पुनः निर्मितानाम् समानानां उपवृक्षाणां बहूनां संख्यां दूरीकर्तुं शक्यते, तस्मात् गणनादक्षतायां सुधारः भवति (आच्छादिताः उपसमस्याः）
केवलं एकवारं सर्वाणि अतिव्याप्त-उप-समस्यानां गणनां कर्तुं, प्रत्येकस्य उप-समस्यायाः समाधानं अभिलेखयितुम् एकं सरणी nem घोषयितुं, अन्वेषणप्रक्रियायाः समये च आच्छादित-उप-समस्यानां छंटनी करणीयम्
- # python 代码示例
- def dfs(i : int, mem : list[int]) -> int :
- if i == 1 or i == 2 :
- return i
- if mem[i] != -1 :
- return mem[i]
- count = dfs(i - 1, mem) + dfs(i - 2, mem)
- # 记录dfs(i)
- mem[i] = count
- return count
- def climbing_stairs_dfs_mem(n : int) -> int :
- mem = [-1] * (n + 1)
- return dfs(n, mem)
- // c++ 代码示例
- int dfs(int i, vector<int> &mem)
- {
- if (i == 1 || i == 2)
- {
- return i ;
- }
- if (mem != -1)
- {
- return mem[i] ;
- }
- int count = dfs(i - 1, mem) + dfs(i - 2, mem) ;
- mem[i] = count ;
- return count ;
- }
- int climbingStairsDFSMem(int n)
- {
- vector<int> mem(n + 1, -1) ;
- return dfs(n, mem) ;
- }
मेमोाइजेशनस्य अनन्तरं सर्वाणि अतिव्याप्ताः उपसमस्याः एकवारमेव गण्यन्ते, तथा च समयजटिलता O(n) यावत् अनुकूलितं भवति ।
कण्ठस्थं अन्वेषणं "ऊर्ध्वतः अधः" पद्धतिः अस्ति वयं मूलसमस्यायाः (मूलनोड्) आरभामः तथा च पुनरावर्तनीयरूपेण बृहत्तराणि उपसमस्यानि लघु उपसमस्यासु विघटनं कुर्मः यावत् वयं लघुतमं ज्ञातां उपसमस्यां (पत्रनोड् ) न समाधानं कुर्मः । . तदनन्तरं उपसमस्यानां समाधानं मूलसमस्यायाः समाधानं निर्मातुं पश्चात्तापद्वारा स्तरं स्तरं एकत्रितं भवति ।
तस्य विपरीतम्, गतिशीलप्रोग्रामिंग् "तलतः उपरि" इति दृष्टिकोणः अस्ति: लघुतमस्य उपसमस्यायाः समाधानेन आरभ्य पुनरावर्तनीयरूपेण बृहत्तरानां उपसमस्यानां समाधानं निर्मातुं यावत् मूलसमस्यायाः समाधानं न प्राप्यते
यतः डायनामिक प्रोग्रामिंग् इत्यत्र बैकट्रैकिंग् प्रक्रिया न भवति, तस्मात् केवलं रिकर्सन् इत्यस्य उपयोगं विना लूप् इटरेशन इत्यस्य उपयोगेन एव कार्यान्वितुं आवश्यकम् ।
- # python 代码示例
- def clibing_stairs_dp(n) :
- if n == 1 or n == 2 :
- return n
- dp = [0] * (n + 1)
- dp[1], dp[2] = 1, 2
- for i in range(3,n + 1) :
- dp[i] = dp[i-1] + dp[i- 2]
- return dp[n]
- // c++ 代码示例
-
- int climbingStairsDP(int n)
- {
- if (n == 1 || n == 2)
- {
- retunr n ;
- }
- vector<int> dp(n + 1, -1) ;
- dp[1] = 1 ;
- dp[2] = 2 ;
- for (int i = 3 ; i <= n ; i++)
- {
- dp[i] = dp[i - 1] + dp[i- 2] ;
- }
- return dp[n] ;
- }
बैकट्रैकिंग् एल्गोरिदम् इत्यस्य सदृशं डायनामिक प्रोग्रामिंग् अपि समस्यानिराकरणस्य विशिष्टं चरणं प्रतिनिधितुं "स्टेट्" इत्यस्य अवधारणायाः उपयोगं करोति । उदाहरणम् : सोपान-आरोहण-समस्यायाः स्थितिः वर्तमान-सोपानस्य i क्रमः इति परिभाषिता अस्ति ।
उपर्युक्तानां आधारेण वयं गतिशीलपदानां सामान्यपदानां सारांशं दातुं शक्नुमः :
dp[i] केवलं dp[i-1] तथा dp[i-2] इत्यनेन सह सम्बद्धः अस्ति ।
सर्वेषां उपसमस्यानां समाधानं संग्रहीतुं सरणीयाः उपयोगस्य स्थाने अग्रे स्क्रॉल कर्तुं केवलं द्वौ चरौ आवश्यकौ भवतः ।
- # python 代码示例
- def clibing_stairs_dp_comp(n) :
- if n == 1 or n == 2 :
- return n
- a, b = 1, 2
- for _ in range(3, n + 1) :
- a, b = b , a + b
- return b
- // c++ 代码示例
- int climbingStairsComp(int n)
- {
- if (n == 1 || n == 2)
- {
- return n ;
- }
- int a = 1 , b = 2 ;
- for (int i = 3 ; i <= n ; i++)
- {
- int temp = b ;
- b = a + b ;
- a = temp ;
- }
- return b ;
- }
सरणी dp द्वारा आक्रान्तं स्थानं लोप्यते, स्थानजटिलता च O(n) तः O(1) पर्यन्तं न्यूनीकृता भवति ।
गतिशीलप्रोग्रामिंगसमस्यासु वर्तमानस्थितिः केवलं पूर्वस्थितीनां सीमितसङ्ख्यायाः सह सम्बद्धा भवति अस्मिन् समये वयं केवलं आवश्यकानि अवस्थानि धारयितुं शक्नुमः तथा च "आयामी न्यूनीकरणस्य" माध्यमेन स्मृतिस्थानं रक्षितुं शक्नुमः । . इयं स्पेस अनुकूलनप्रविधिः "rolling variables" अथवा "rolling arrays" इति कथ्यते ।
सः ३० वर्षाणाम् अधिकं कालात् प्रौद्योगिक्याः शोधकार्यं कर्तुं समर्पितः अस्ति, तथा च जावा, लिनक्स, जावास्क्रिप्ट्, php, css इत्यादिषु विविधभाषासु प्रवीणः अस्ति, मुक्तस्रोतक्षेत्रे सः बहु योगदानं कृतवान् अस्ति developer documentation station भविष्ये सन्दर्भार्थं प्रौद्योगिकीविकासे केचन विषयाः साझां कर्तुं सर्वे तत् पश्यन्तु
