అతిపెద్ద చుట్టుకొలత ట్రయాంగిల్ లీట్‌కోడ్ పరిష్కారం


కఠినత స్థాయి సులువు
తరచుగా అడుగుతుంది C3 IoT
మఠం సార్టింగ్

సమస్యల నివేదిక

సమస్యలో ”పెద్దది పెరీమీటర్ త్రిభుజం ”మనకు n విలువలతో శ్రేణి ఇవ్వబడుతుంది. అన్ని విలువలు సానుకూల పూర్ణాంకాలు. ఈ విలువల నుండి మనం నిర్మించగల త్రిభుజం యొక్క గరిష్ట చుట్టుకొలతను కనుగొనమని ప్రశ్న అడగండి. ఒకవేళ త్రిభుజాన్ని నిర్మించడం సాధ్యం కాకపోతే మనం 0 ప్రింట్ చేయాలి.

ఉదాహరణ

arr = [3,2,3,4]
10

వివరణ: ఈ విలువలను ఉపయోగించి ఏర్పడే త్రిభుజం యొక్క అతిపెద్ద చుట్టుకొలత 10 మరియు త్రిభుజాల వైపులా 4,3,3.

అతిపెద్ద చుట్టుకొలత ట్రయాంగిల్ లీట్‌కోడ్ పరిష్కారం కోసం విధానం

ఇది ప్రాథమిక గణిత సమస్య. కాబట్టి దాన్ని పరిష్కరించడానికి ఈ సిద్ధాంతాన్ని మనం తెలుసుకోవాలి, ఏదైనా రెండు వైపుల పొడవు యొక్క త్రిభుజం మొత్తంలో ఎల్లప్పుడూ మూడవ వైపు కంటే ఎక్కువగా ఉంటుంది. లేకపోతే, అవి త్రిభుజం ఏర్పడవు. త్రిభుజం వైపులా ఉన్నాయని చెప్పండి a, b, మరియు c. ఈ సిద్ధాంతాన్ని సంతృప్తిపరచకపోతే త్రిభుజాన్ని ఎలా నిర్మించడం సాధ్యం కాదని చిత్రాలు చూపుతాయి.

అతిపెద్ద చుట్టుకొలత త్రిభుజానికి లీట్‌కోడ్ పరిష్కారం

ప్రశ్న అతిపెద్ద చుట్టుకొలత త్రిభుజాన్ని కనుగొనమని అడిగినప్పుడు, ఒక + b> c, b + c> a, మరియు a + c> b పరిస్థితులను సంతృప్తిపరిచే అన్ని త్రిపాదిలలో మనం ఒక + b + c గరిష్టంగా ఉంటుంది.

కాబట్టి అతిపెద్ద చుట్టుకొలతను పొందడానికి వీలైనంత పెద్ద, బి, సి విలువలను మేము కోరుకుంటున్నాము. మేము శ్రేణిని క్రమబద్ధీకరిస్తాము మరియు వారు సిద్ధాంతాన్ని సంతృప్తిపరిస్తే అతిపెద్ద మూడు విలువలతో ప్రారంభిస్తాము. అది జరిగితే వాటి మొత్తం అవసరమైన విలువ. లేకపోతే, మేము తదుపరి మూడు అతిపెద్ద విలువలను తనిఖీ చేస్తాము.

అటువంటి త్రిపాది ఏదీ లేకపోతే త్రిభుజం యొక్క అతిపెద్ద చుట్టుకొలత 0.

 అమలు

అతిపెద్ద చుట్టుకొలత త్రిభుజం కోసం C ++ కోడ్

#include <bits/stdc++.h> 
using namespace std; 
    int largestPerimeter(vector<int>&  arr) {
        int n=arr.size();
        sort(arr.begin(),arr.end());
       for (int i =n - 1; i > 1; --i)
            if (arr[i] < arr[i - 1] + arr[i - 2])
                return arr[i] + arr[i - 1] + arr[i - 2];
        return 0;
    }
int main() 
{ 
 vector<int> arr = { 3,2,3,4 }; 
 cout<<largestPerimeter(arr)<<endl; 
 return 0;
}
10

అతిపెద్ద చుట్టుకొలత త్రిభుజం కోసం జావా కోడ్

import java.util.Arrays; 
public class Tutorialcup {
    public static int largestPerimeter(int[] arr) {
        Arrays.sort(arr);
        int n= arr.length;
        for (int i =n - 1; i > 1; --i)
            if (arr[i] < arr[i - 1] + arr[i - 2])
                return arr[i] + arr[i - 1] + arr[i - 2];
        return 0;
    }
  public static void main(String[] args) {
    int [] arr = {3,2,3,4}; 
    int ans= largestPerimeter(arr);
    System.out.println(ans);
  }
}

 

10

అతిపెద్ద చుట్టుకొలత ట్రయాంగిల్ లీట్‌కోడ్ పరిష్కారం యొక్క సంక్లిష్టత విశ్లేషణ

సమయం సంక్లిష్టత

పై కోడ్ యొక్క సమయం సంక్లిష్టత O (nlogn) ఎందుకంటే మేము శ్రేణిని క్రమబద్ధీకరిస్తున్నాము. ఇక్కడ n అనేది శ్రేణి యొక్క పరిమాణం.

స్థల సంక్లిష్టత

పై కోడ్ యొక్క స్థల సంక్లిష్టత O (1) ఎందుకంటే మేము జవాబును నిల్వ చేయడానికి వేరియబుల్ మాత్రమే ఉపయోగిస్తున్నాము.

ప్రస్తావనలు