ចាត់ចែងខូឃីស៍ឡឺយកូដកូដ


កម្រិតលំបាក មានភាពងាយស្រួល
សួរញឹកញាប់ ក្រុមហ៊ុន Amazon
លោភលន់

បញ្ហាចាត់ចែងខុកឃីឡេហ្សិចសូលូសិនផ្តល់នូវអារេពីរ។ មួយ​ក្នុង​ចំណោម អារេ តំណាងទំហំខុកឃីនិងមួយទៀតតំណាងឱ្យភាពលោភលន់របស់កុមារ។ បញ្ហាបញ្ជាក់ថាអ្នកជាឪពុកម្តាយរបស់កុមារហើយអ្នកចង់អោយចំនួនកុមារច្រើនបំផុតជាមាតិកា។ អ្នកអាចផ្តល់ខូឃីតែមួយប៉ុណ្ណោះដល់កុមារ។ រកចំនួនមាតិកាមាតិកាអតិបរិមា។ សូមលើកឧទាហរណ៍មួយចំនួនជាមុនសិន។

g = [1,2,3], s = [1,1]
1

ការពន្យល់ៈយើងមានខូឃីស៍ចំនួន ២ ដែលមានទំហំ ១ និងកូន ៣ នាក់ដែលមានតម្លៃមាតិកាខុសគ្នា។ យើងអាចបង្កើតមាតិកាកុមារតែមួយប៉ុណ្ណោះដែលមានតម្លៃលោភលន់។ ចាប់តាំងពីក្មេងពីរនាក់ផ្សេងទៀតត្រូវការនំធំ។

ចាត់ចែងខូឃីស៍ឡឺយកូដកូដ

g = [1,2], s = [1,2,3]
2

ការពន្យល់ៈយើងអាចធ្វើឱ្យកុមារទាំងពីរមានអារម្មណ៍ខ្លឹមសារពីព្រោះខូឃីស៍ដែលយើងមានធំជាងឬស្មើនឹងទំហំដែលត្រូវការ។ ដូច្នេះលទ្ធផលគឺ ២ ។

វិធីសាស្រ្តក្នុងការផ្តល់ដំណោះស្រាយឃុកឃីឡេធីកូដ

បញ្ហាផ្តល់ដំណោះស្រាយឃុកឃីឡេធីកូដសួរយើងរកចំនួនកុមារមាតិកាច្រើនបំផុតប្រសិនបើយើងអាចផ្តល់ខូឃីតែមួយដល់កុមារ។ ដូច្នេះវិធីសាស្រ្តល្អបំផុតគឺការព្យាយាមលោភលន់ដើម្បីធ្វើឱ្យក្មេងលោភលន់មានអារម្មណ៍ថាមានមាតិកាជាមួយខូឃីតិចបំផុតដែលអាចប្រើបាន។ ដូច្នេះដើម្បីត្រាប់តាមដំណើរការនេះយើងតម្រៀបតាមអារេដែលបានផ្តល់ហើយព្យាយាមដាក់ខូឃីស៍ដល់កុមារ។ ប្រសិនបើយើងមិនអាចផ្តល់ខូឃីបច្ចុប្បន្នដល់កូនបច្ចុប្បន្នទេនោះយើងនឹងសាកល្បងខូឃីបន្ទាប់រហូតដល់យើងពេញចិត្តកូនបច្ចុប្បន្ន។ ពីព្រោះប្រសិនបើយើងមិនអាចផ្គាប់ចិត្តកូនបច្ចុប្បន្នបានទេយើងមិនអាចផ្គាប់ចិត្តក្មេងៗបន្ទាប់ដោយប្រើខូឃីបច្ចុប្បន្នបានទេ។

លេខកូដ

លេខកូដ C ++ សំរាប់ចាត់ចែងខូឃីស៍ឡេសកូដកូដ

#include <bits/stdc++.h>
using namespace std;

int findContentChildren(vector<int>& g, vector<int>& s) {
    sort(g.begin(), g.end());
    sort(s.begin(), s.end());
    int numberOfChildren = g.size(), numberOfCookies = s.size();
    int cookie = 0, answer = 0;
    for(int i=0;i<numberOfChildren && cookie<numberOfCookies;){
        if(s[cookie] >= g[i]){
            i++;
            answer++;
        }
        cookie++;
    }
    return answer;
}

int main(){
    vector<int> g = {1, 2, 3};
    vector<int> s = {1, 1};

    cout<<findContentChildren(g, s);
}
1

កូដចាវ៉ាសំរាប់ចាត់ចែងខូឃីស៍ឡេឡេកូដកូដ

import java.util.*;
import java.lang.*;
import java.io.*;
 
class Ideone
{
    public static int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int numberOfChildren = g.length;
        int numberOfCookies = s.length;
        int cookie = 0, answer = 0;
        for(int i=0;i<numberOfChildren && cookie<numberOfCookies;){
            if(s[cookie] >= g[i]){
                i++;
                answer++;
            }
            cookie++;
        }
        return answer;
    }
 
  public static void main (String[] args) throws java.lang.Exception
  {
    int[] g = {1, 2, 3};
    int[] s = {1, 1};
 
    System.out.println(findContentChildren(g, s));
  }
}
1

ការវិភាគស្មុគស្មាញ

ស្មុគស្មាញពេលវេលា

O (NlogN), ដោយសារតែពេលវេលាដែលត្រូវការដើម្បីតម្រៀបអារេដែលបានផ្តល់ឱ្យ។ នៅទីនេះ N តំណាងឱ្យចំនួនធាតុនៅក្នុងអារេដែលបានផ្តល់ឱ្យ។

ភាពស្មុគស្មាញនៃលំហ

O (NlogN), ដោយសារតែចន្លោះត្រូវការដើម្បីតម្រៀបអារេដែលបានផ្តល់។ ជាថ្មីម្តងទៀត N តំណាងឱ្យចំនួនធាតុនៅក្នុងអារេ។