സ്റ്റോക്ക് III ലീറ്റ്കോഡ് പരിഹാരം വാങ്ങാനും വിൽക്കാനുമുള്ള മികച്ച സമയം


വൈഷമ്യ നില ഹാർഡ്
പതിവായി ചോദിക്കുന്നു അഡോബി ആമസോൺ
അറേ ഡൈനാമിക് പ്രോഗ്രാമിംഗ്

പ്രശ്നം പ്രസ്താവന

“സ്റ്റോക്ക് III വാങ്ങാനും വിൽക്കാനുമുള്ള മികച്ച സമയം” എന്ന പ്രശ്‌നത്തിൽ, അറേയിലെ ഓരോ ഘടകങ്ങളും ആ ദിവസം നൽകിയ സ്റ്റോക്കിന്റെ വില ഉൾക്കൊള്ളുന്ന ഒരു അറേ ഞങ്ങൾക്ക് നൽകിയിരിക്കുന്നു.

നിർവചനം ഇടപാട് ഒരു ഓഹരി ഓഹരി വാങ്ങുകയും സ്റ്റോക്കിന്റെ ഒരു പങ്ക് വിൽക്കുകയും ചെയ്യുന്നു.

ഇനിപ്പറയുന്ന നിയന്ത്രണങ്ങൾക്ക് കീഴിൽ പരമാവധി ലാഭം കണ്ടെത്തുക എന്നതാണ് ഞങ്ങളുടെ ചുമതല:

  1. മുമ്പത്തെ സ്റ്റോക്ക് ഞങ്ങൾ വിറ്റില്ലെങ്കിൽ ഞങ്ങൾക്ക് ഒരു പുതിയ സ്റ്റോക്ക് വാങ്ങാൻ കഴിയില്ല. അത് ഞങ്ങൾക്ക് ഒരു സ്റ്റോക്ക് പരമാവധി കൈവരിക്കാവുന്ന ഒരു സമയത്താണ്.
  2. ഞങ്ങൾക്ക് പരമാവധി രണ്ട് ഇടപാടുകൾ ചെയ്യാൻ കഴിയും.

ഉദാഹരണം

prices = [1,2,3,4,5]
4

വിശദീകരണം: ലഭിക്കുന്ന പരമാവധി ലാഭം 4. ഇടപാട് വിശദാംശങ്ങൾ ചുവടെ:

ആദ്യ ദിവസം: വാങ്ങുക

രണ്ടാം ദിവസം: വിശ്രമം

മൂന്നാം ദിവസം: വിശ്രമം

നാലാം ദിവസം: വിശ്രമം

അഞ്ചാം ദിവസം: വിൽക്കുക

സ്റ്റോക്ക് III ലീറ്റ്കോഡ് പരിഹാരം വാങ്ങാനും വിൽക്കാനുമുള്ള മികച്ച സമയത്തിനുള്ള സമീപനം

ഈ പ്രശ്‌നം ഇതിന്റെ കഠിനമായ പതിപ്പാണ് സ്റ്റോക്ക് വാങ്ങാനും വിൽക്കാനുമുള്ള മികച്ച സമയം. അതിനാൽ ഈ പ്രശ്‌നത്തിലേക്ക് ചാടുന്നതിന് മുമ്പ് പ്രശ്നത്തിന്റെ എളുപ്പ പതിപ്പ് പരിഹരിക്കണം.

ഞങ്ങൾക്ക് ഇവിടെ ഒരു ഇടപാട് മാത്രമേ ചെയ്യാൻ കഴിയൂ എന്ന എളുപ്പ പതിപ്പുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, ഞങ്ങൾക്ക് പരമാവധി രണ്ട് ഇടപാടുകൾ ചെയ്യാൻ കഴിയും. അതായത് പരമാവധി ലാഭം നൽകുന്ന രീതിയിൽ ഒരു ഇടപാട് അല്ലെങ്കിൽ രണ്ട് ഇടപാടുകൾ.

രണ്ടാമത്തെ ഇടപാട് എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്നതാണ് പ്രശ്നത്തിന്റെ തന്ത്രപരമായ ഭാഗം. ഈ പ്രശ്നം കാണുന്നതിന് ഞങ്ങളുടെ കാഴ്ചപ്പാട് മാറ്റിക്കഴിഞ്ഞാൽ, ഈ പ്രശ്നത്തെ ഈ പ്രശ്നത്തിന്റെ എളുപ്പ പതിപ്പായി പരിവർത്തനം ചെയ്യാൻ കഴിയും.

200 രൂപ ലാഭത്തോടെ ഞങ്ങൾ ആദ്യത്തെ ഇടപാട് പൂർത്തിയാക്കി എന്ന് പറയാം. (ഈ ഭാഗം സമാനമാണ് സ്റ്റോക്ക് വാങ്ങാനും വിൽക്കാനുമുള്ള മികച്ച സമയം). അതിനാൽ ആദ്യത്തെ ഇടപാടിന് ശേഷം ഞങ്ങളുടെ കയ്യിൽ 200 രൂപയുണ്ട്.

ഇപ്പോൾ ഞങ്ങൾ 500 രൂപ സ്റ്റോക്ക് വാങ്ങാൻ പോകുമ്പോൾ. സ്റ്റോക്കിന്റെ വില 500 രൂപയാണെങ്കിലും നമുക്ക് ഇത് പോലെ ചിന്തിക്കാം. എന്നാൽ ഞങ്ങളെ സംബന്ധിച്ചിടത്തോളം ഇത് 300 രൂപയാണ്, കാരണം ഞങ്ങളുടെ കയ്യിൽ ഇതിനകം 200 രൂപയുണ്ട്, ഞങ്ങൾക്ക് ഇത് സ got ജന്യമായി ലഭിച്ചു. ഇപ്പോൾ ഞങ്ങൾ ചെയ്ത അതേ രീതിയിൽ അറ്റാദായം വർദ്ധിപ്പിക്കുന്നതിന് ഞങ്ങൾ രണ്ടാമത്തെ ഇടപാട് നടത്തും സ്റ്റോക്ക് വാങ്ങാനും വിൽക്കാനുമുള്ള മികച്ച സമയം പ്രശ്നം.

ഈ ഉദാഹരണത്തിൽ നിന്ന് സമീപനം കൂടുതൽ വ്യക്തമാകും:

സ്റ്റോക്ക് III വാങ്ങാനും വിൽക്കാനുമുള്ള മികച്ച സമയത്തിനുള്ള ലീറ്റ്കോഡ് പരിഹാരം

നടപ്പിലാക്കൽ

സ്റ്റോക്ക് III വാങ്ങാനും വിൽക്കാനുമുള്ള മികച്ച സമയത്തിനുള്ള ജാവ കോഡ്

import java.util.Arrays; 
public class Tutorialcup {
    public static int maxProfit(int[] prices) {
  int firstSell = 0;
  int secondSell = 0;
  int firstBuy = Integer.MAX_VALUE;
  int secondBuy = Integer.MAX_VALUE;
  for(int i = 0; i < prices.length; i++) {
    int p = prices[i];
    firstBuy = Math.min(firstBuy, p);
    firstSell = Math.max(firstSell, p - firstBuy);
    secondBuy = Math.min(secondBuy, p - firstSell);
    secondSell = Math.max(secondSell, p - secondBuy);
  }
  
  return secondSell;
    }
  public static void main(String[] args) {
    int [] arr = {1,2,3,4,5}; 
    int ans=  maxProfit(arr);
    System.out.println(ans);
  }
}
4

സ്റ്റോക്ക് III വാങ്ങാനും വിൽക്കാനുമുള്ള മികച്ച സമയത്തിനുള്ള സി ++ കോഡ്

#include <bits/stdc++.h> 
using namespace std; 
     int maxProfit(vector<int>& prices) {
  int firstSell = 0;//stores profit after one sell
  int secondSell = 0;//stores profit after two sell
  int firstBuy = INT_MAX;
  int secondBuy = INT_MAX;
  int n=prices.size();
        for(int i=0;i<n;i++)
        {
            firstBuy=min(firstBuy,prices[i]);
            firstSell=max(firstSell,prices[i]-firstBuy);
            secondBuy=min(secondBuy,prices[i]-firstSell);
            secondSell=max(secondSell,prices[i]-secondBuy); 
        }
        return secondSell;
    }
int main() 
{ 
 vector<int> arr = { 1,2,3,4,5 }; 
 cout<<maxProfit(arr)<<endl; 
 return 0;
}
4

സ്റ്റോക്ക് III ലീറ്റ്കോഡ് പരിഹാരം വാങ്ങാനും വിൽക്കാനുമുള്ള മികച്ച സമയത്തിന്റെ സങ്കീർണ്ണത വിശകലനം

സമയ സങ്കീർണ്ണത

മുകളിലുള്ള കോഡിന്റെ സമയ സങ്കീർണ്ണതയാണ് O (n) കാരണം ഞങ്ങൾ വില ശ്രേണിയിൽ ഒരു തവണ മാത്രമേ സഞ്ചരിക്കുന്നുള്ളൂ. വില നിരയുടെ ദൈർഘ്യം ഇവിടെ n ആണ്.

സ്ഥല സങ്കീർണ്ണത

മുകളിലുള്ള കോഡിന്റെ സ്ഥല സങ്കീർണ്ണത O (1) കാരണം ഉത്തരം സംഭരിക്കാൻ മാത്രമാണ് ഞങ്ങൾ മെമ്മറി ഉപയോഗിക്കുന്നത്.

അവലംബം