选择排序
思路：选择排序也是一种贪心算法，每次选择当前未排序数组中的最小值，和未排序数组的头进行交换。
代码：
void mysel_sort(vector<int> &nums){
for (int i = 0; i < nums.size()-1; ++i) {
int smallest = i;
for(int j = i+1;j<nums.size();++j)
{
if(nums[j] < nums[smallest])
smallest = j;
}
if(smallest != i)
swap(nums[i],nums[smallest]);
}
}
力扣 1221.分割平衡字符串
在一个「平衡字符串」中，‘L’ 和 ‘R’ 字符的数量是相同的。
给出一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。
返回可以通过分割得到的平衡字符串的最大数量。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/split-a-string-in-balanced-strings
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路：
贪心策略：不让平衡字符串嵌套
代码：
class Solution {
public:
int balancedStringSplit(string s) {
int cnt = 0;
int balance = 0;
for(int i = 0;i<s.length();++i){
if(s[i] == 'R')
--balance;
else if(s[i] == 'L')
++balance;
if(balance == 0)
++cnt;
}
return cnt;
}
};
力扣 122. 买卖股票的最佳时机 II
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路：
贪心策略：连续上涨的时候低点买入高点卖出和只要后一天上涨，前一天就买入这种多次交易获取的利润是一样的
连续下跌的时候不做交易
代码：
class Solution {
public:
int maxProfit(vector<int>& prices) {
int profit = 0;
for(int i = 1; i<prices.size();++i){
if(prices[i] > prices[i-1])
{
profit += prices[i] - prices[i-1];
}
}
return profit;
}
};
钱币找零
假设1元、2元、5元、10元、20元、50元、100元的纸币分别有c0, c1, c2, c3, c4, c5, c6张。现在要用这些钱来支付K
元，至少要用多少张纸币？
思路：
贪心策略：很显然，每一步尽可能用面值大的纸币即可。在日常生活中我们自然而然也是这么做的。在程序中已经事先将value按照从小到大的顺序排好了
代码：
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct cmp{
bool operator()(vector<int>& array1, vector<int>& array2 ){
return array1[0] > array2[0];
}
};
//找零钱算法
int maxNum(vector<vector<int>>& moneyMat,int money){
//0:面值 1:个数
sort(moneyMat.begin(),moneyMat.end(),cmp());
int cnt = 0;
for(auto arr : moneyMat){
//需要的纸币的个数
int c = money / arr[0];
c = min(c, arr[1]);
//减去找过的钱
money -= c * arr[0];
cnt += c;
}
if (money != 0)
return -1;
return cnt;
}
int main()
{
vector<vector<int>> moneyMat = {
{
1,10},{
100,20},{
5,5},{
50,3},{
20,9},{
10,1},{
2,5}};
int money;
cin>>money;
cout<<maxNum(moneyMat,money)<<endl;
}
多机调度
某工厂有n个独立的作业，由m台相同的机器进行加工处理。作业i所需的加工时间为ti，任何作业在被处理时不能中
断，也不能进行拆分处理。现厂长请你给他写一个程序：算出n个作业由m台机器加工处理的最短时间
输入
第一行T（1<T<100)表示有T组测试数据。每组测试数据的第一行分别是整数n，m（1<=n<=10000，
1<=m<=100），接下来的一行是n个整数ti（1<=t<=100)。
输出
所需的最短时间
思路：
当n<=m时，将作业分给每一个机器即可；当n>=m时，首先将n个作业从大到小排序，然后依此顺序将作业分配给空闲的处理机。如果我们每次是将需要处理时间最短的作业分配给空闲的机器，那么可能就会出现其它所有作业都处理完了只剩所需时间最长的作业在处理的情况，这样势必效率较低。
代码：
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool cmp (const int& x, const int& y){
return x > y;
}
int findMax(const vector<int>& machines){
int ret = machines[0];
for (const auto& cur :machines) {
if(ret < cur)
ret = cur;
}
return ret;
}
int greedStrategy(vector<int>& works,vector<int>& machines){
//按作业时间从大到小
sort(works.begin(),works.end(),cmp);
int workNum = works.size();
int machinesNum = machines.size();
//作业数小于机器数
if (workNum <= machinesNum){
int minimalTime = works[0];
return minimalTime;
}
else{
//为每一个作业选择机器
for (int i = 0; i < workNum; ++i) {
int flag = 0;
int tmp = machines[flag];
for (int j = 1; j < machines.size(); ++j) {
if(tmp > machines[j]){
flag = j;
tmp =machines[j];
}
}
machines[flag] += works[i];
}
int minmalTime = findMax(machines);
return minmalTime;
}
}
int main()
{
int n,m;
cin >>n >>m;
vector<int> works(n);
vector<int> machines(m,0);
for (int i = 0; i < n; ++i) {
cin >>works[i];
}
cout<<greedStrategy(works,machines)<<endl;
return 0;
}