மிகப்பெரிய சுற்றளவு முக்கோண லீட்கோட் தீர்வு


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது சி 3 ஐஓடி
கணித வரிசையாக்க

சிக்கல் அறிக்கை

சிக்கலில் ”மிகப்பெரியது சுற்றளவு முக்கோணம் ”எங்களுக்கு 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 அதிகபட்சம்.

ஆகவே, மிகப்பெரிய சுற்றளவு பெற முடிந்தவரை பெரிய, a, b மற்றும் c இன் மதிப்புகளை நாங்கள் விரும்புகிறோம். நாங்கள் வரிசையை வரிசைப்படுத்துவோம், பின்னர் அவை தேற்றத்தை பூர்த்தி செய்தால் மிகப்பெரிய மூன்று மதிப்புகளுடன் தொடங்குவோம். அவ்வாறு செய்தால் அவற்றின் தொகை தேவையான மதிப்பு. இல்லையெனில், அடுத்த மூன்று மிகப்பெரிய மதிப்புகளை நாங்கள் சோதிப்போம்.

அத்தகைய மும்மடங்கு எதுவும் இல்லை என்றால், முக்கோணத்தின் மிகப்பெரிய சுற்றளவு 0 ஆகும்.

 நடைமுறைப்படுத்தல்

மிகப்பெரிய சுற்றளவு முக்கோணத்திற்கான சி ++ குறியீடு

#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

மிகப்பெரிய சுற்றளவு முக்கோண லீட்கோட் தீர்வின் சிக்கலான பகுப்பாய்வு

நேர சிக்கலானது

மேலே உள்ள குறியீட்டின் நேர சிக்கலானது ஓ (nlogn) ஏனென்றால் நாங்கள் வரிசையை வரிசைப்படுத்துகிறோம். இங்கே n என்பது வரிசையின் அளவு.

விண்வெளி சிக்கலானது

மேலே உள்ள குறியீட்டின் இட சிக்கலானது ஓ (1) ஏனென்றால் பதிலைச் சேமிக்க ஒரு மாறி மட்டுமே பயன்படுத்துகிறோம்.

குறிப்புகள்