Data Structures and Algorithms - greedy algorithm

#include  "pch.h"
#include <iostream>
#include <stdio.h>


int main()
{
    const int RMB[] = { 200, 100, 20, 5, 1 };
    const int NUM = 5;
    int X = 628;
    int count = 0;
    for (int i = 0; i < NUM; i++) {
        int use = X / RMB[i];
        COUNT + = use; 
        X- = X-- RMB [I] * use; 
        the printf ( " required denomination% d% d in Zhang, " , RMB [I], use); 
        the printf ( " . The remaining required payment amount% d \ n- " , X-); 
    } 
    the printf ( " requires a total of% d \ n- " , COUNT);
     return  0 ; 
}

First, the sub-candy

Second, the swing sequence

 

class Solution {
public:
    int wiggleMaxLength(std::vector<int>& nums) {
        if (nums.size()< 2)
        {
            return nums.size();
        }
        static const int BEGIN = 0;
        static const int UP = 1;
        static const int DOWN = 2;
        int STATE = BEGIN;
        int max_length = 1;
        for (int i =1; i < nums.size(); i++){
            switch(STATE){
                case BEGIN:
                    if(nums[i-1] < nums[i]){
                        STATE = UP;
                        max_length++;
                    }
                    else if (nums[i-1] > nums[i]){
                        STATE = DOWN;
                        max_length++;
                    }
                    break;
                case UP:
                    if(nums[i-1] > nums[i]){
                        STATE = DOWN;
                        max_length++;
                    }
                    break;
                case DOWN:
                    if(nums[i-1] < nums[i]){
                        STATE = UP;
                        max_length++;
                    }
                    break;
            }
        }
        return max_length++;
    }
};

Third, remove the K numbers

 

class Solution {
 public :
     String removeKdigits ( String NUM, int K) { 
        STD :: Vector < int > S; S // is an integer array, when the stack with 
        STD :: String Result = "" ;
         for ( int I = 0 ; I <num.length (); I ++ ) 
        { 
            int Number = num [I] - ' 0 ' ; // num character into an integer
             the while ! (s.size () = 0 && S [s.size () - . 1 ]> Number && K> 0){
                S.pop_back();
                k--;
            }
            if(number != 0 || S.size() != 0){
                S.push_back(number);
            }
        }
        while (S.size() != 0 && k > 0 ) 
        {
            S.pop_back();
            k--;
        }
        for(int i = 0; i < S.size(); i++)
        {
            result.append(1, '0' + S [I]); // integer into character 
        } 
        IF (Result == "" ) { 
            Result = " 0 " ; 
        } 
        return Result; 
    } 
};

Fourth, jumping game

 

 

class Solution {
public:
    bool canJump(vector<int>& nums) {
        std::vector<int> index;
        for(int i = 0; i < nums.size(); i++)
        {
            index.push_back(i + nums[i]);
        }
        int jump = 0;
        int max_index = index[0];
        while(jump < nums.size() && jump <= max_index)
        {
            if(max_index < index[jump])
            {
                max_index = index[jump];
            }
            jump++;
        }
        if(jump == nums.size())
        {
            return true;
        }
        return false;
    }
};

Fifth, shooting balloons

 

Sixth, the best method for refueling

#define _CRT_SECURE_NO_WARNINGS
#include  "pch.h"
#include <iostream>
#include <stdio.h>
#include <queue>
#include <algorithm>


bool cmp(const std::pair<int, int> &a, const std::pair<int, int> &b) {
    return a.first > b.first;
}
int get_minimum_stop(int L, int P, std::vector<std::pair<int, int> > &stop) 
{
    std::priority_queue<int> Q;
    int result = 0;
    stop.push_back(std::make_pair(0, 0));
    std::sort(stop.begin(), stop.end(), cmp);
    for (int i = 0; i < stop.size(); i++) 
    {
        int dis = L - stop[i].first;
        while ( !Q.empty() && P < dis) {
            P += Q.top();
            Q.pop();
            result++;
        }
        if (P < dis && Q.empty()) {
            return -1;
        }
        P = P - dis;
        L = stop[i].first;
        Q.push(stop[i].second);
    }
    return result;
}


int main()
{
    std::vector<std::pair<int, int> >stop;
    int N;
    int L;
    int P;
    int distance;
    int fuel;
    scanf("%d", &N);
    for (int i = 0; i < N; i++) {
        scanf("%d %d", &distance, &fuel);
        stop.push_back(std::make_pair(distance, fuel));
    }
    scanf("%d %d", &L, &P);
    printf("%d\n", get_minimum_stop(L, P, stop));
    return 0;
}