算法基础知识——贪心策略（二）
目录：
- 应用实例
- 变态跳台阶【剑指Offer_编程题】
- 牛牛找工作【网易】
- 最大乘积【拼多多】
- 剪绳子【剑指Offer_编程题】
- 最大差值【美团】
- 俄罗斯方块【网易】
- 分苹果【网易】
- 回文序列【网易】
- 六一儿童节【拼多多】
- 保留最大的数【搜狐】
- 末尾0的个数【滴滴】
- 瞌睡【网易】
- gas-station【LeetCode】
- 裁剪网格纸【百度】
- 餐馆【滴滴】
一、应用实例：
1、题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。int jumpFloorII(int number) {}【剑指Offer_编程题】
- 输入格式：台阶级数n
- 输出格式：跳法总数
- 样例输入：无
- 样例输出：无
示例代码：
class Solution {
public:
long long jumpFloorII(int number){
long long result = 1;
if(number != 0 && number != 1){
for(int i = 2; i <= number; i++){
result *= 2;
}
}
return result;
}
};2、题目描述：为了找到自己满意的工作，牛牛收集了每种工作的难度和报酬。牛牛选工作的标准是在难度不超过自身能力值的情况下，牛牛选择报酬最高的工作。在牛牛选定了自己的工作后，牛牛的小伙伴们来找牛牛帮忙选工作，牛牛依然使用自己的标准来帮助小伙伴们。牛牛的小伙伴太多了，于是他只好把这个任务交给了你。【网易】
- 输入格式：每个输入包含一个测试用例。每个测试用例的第一行包含两个正整数，分别表示工作的数量N(N<=100000)和小伙伴的数量M(M<=100000)。接下来的N行每行包含两个正整数，分别表示该项工作的难度Di(Di<=1000000000)和报酬Pi(Pi<=1000000000)。接下来的一行包含M个正整数，分别表示M个小伙伴的能力值Ai(Ai<=1000000000)。保证不存在两项工作的报酬相同。
- 输出格式：对于每个小伙伴，在单独的一行输出一个正整数表示他能得到的最高报酬。一个工作可以被多个人选择。
- 样例输入：
- 3 3
- 1 100
- 10 1000
- 1000000000 1001
- 9 10 1000000000
- 样例输出：
- 100
- 1000
- 1001
示例代码：
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int MAX_N = 100001;
struct Node{
int difficult;
int pay;
Node(int d, int p):difficult(d), pay(p){};
bool operator<(const Node &n)const{
return difficult < n.difficult;
};
};
struct Person{
int ability;
int index;
Person(int a, int i):ability(a), index(i){};
bool operator<(const Person &p)const{
return ability < p.ability;
};
};
vector<Node> nodeList;
vector<Person> abilityList;
int result[MAX_N];
int main(){
int n, m; //n为工作数，m为人数
while(cin >> n >> m){
int di, pi, a;
nodeList.clear();
abilityList.clear();
for(int i = 0; i < n; i++){
cin >> di >> pi;
nodeList.push_back(Node(di, pi));
}
for(int i = 0; i < m; i++){
cin >> a;
abilityList.push_back(Person(a, i));
}
sort(nodeList.begin(), nodeList.end());
sort(abilityList.begin(), abilityList.end());
int maxSalary = 0, index = 0;
for(int i = 0; i < m; i++){
for(int j = index; j < nodeList.size(); j++){
if(nodeList[j].difficult <= abilityList[i].ability){
if(maxSalary < nodeList[j].pay){
maxSalary = nodeList[j].pay;
result[abilityList[i].index] = maxSalary;
}
index++;
}else{
break;
}
}
result[abilityList[i].index] = maxSalary;
}
for(int i = 0; i < m; i++){
cout << result[i] << endl;
}
}
return 0;
}3、题目描述：给定一个无序数组，包含正数、负数和0，要求从中找出3个数的乘积，使得乘积最大，要求时间复杂度：O(n)，空间复杂度：O(1)【拼多多】
- 输入格式：输入共2行，第一行包括一个整数n，表示数组长度。第二行为n个以空格隔开的整数，分别为A1,A2, … ,An
- 输出格式：满足条件的最大乘积
- 样例输入：
- 4
- 3 4 1 2
- 样例输出：
- 24
示例代码1：
#include <iostream>
using namespace std;
const long long MAX_INT = 0x7fffffffffffffff;
const long long MIN_INT = -0x7fffffffffffffff;
//两最大负数，一最大正数，或者三个最大正数，或者最小三个负数
long long pos1;
long long pos2;
long long pos3;
long long negMax1;
long long negMax2;
long long negMin1;
long long negMin2;
long long negMin3;
int main(){
int n;
while(cin >> n){
//flag1表示至少有两个正数，flag2表示有两个负数,flag3表示有正数
bool flag1 = false, flag2 = false, flag3 = false;
pos1 = pos2 = pos3 = MIN_INT;
negMax1 = negMax1 = MAX_INT;
negMin1 = negMin2 = negMin3 = MIN_INT;
int inputNumber;
for(int m = 0; m < n; m++){
cin >> inputNumber;
if(inputNumber < 0){
if(inputNumber <= negMax1){
negMax2 = negMax1;
negMax1 = inputNumber;
}else if(inputNumber > negMax1 && inputNumber <= negMax2){
negMax2= inputNumber;
flag2 = true;
}
if(inputNumber >= negMin1){
negMin3 = negMin2;
negMin2 = negMin1;
negMin1 = inputNumber;
}else if(inputNumber < negMin1 && inputNumber >= negMin2){
negMin3 = negMin2;
negMin2 = inputNumber;
}else if(inputNumber < negMin1 && inputNumber < negMin2 && inputNumber > negMin3){
negMin3 = inputNumber;
}
}else if(inputNumber > 0){
if(inputNumber >= pos1){
pos3 = pos2;
pos2 = pos1;
pos1 = inputNumber;
flag3 = true;
}else if(inputNumber < pos1 && inputNumber >= pos2){
pos3 = pos2;
pos2 = inputNumber;
flag1 = true;
}else if(inputNumber < pos1 && inputNumber < pos2 && inputNumber > pos3){
pos3 = inputNumber;
}
}
}
long long result = 1;
if(!flag1){
result = pos1 * negMax1 * negMax2;
}else if(!flag2){
result = pos1 * pos2 * pos3;
}else if(!flag3){
result = negMin1 * negMin2 * negMin3;
}else{
long long result1 = pos1 * pos2 * pos3;
long long result2 = negMax1 * negMax2 * pos1;
result = max(result1, result2);
}
cout << result << endl;
}
return 0;
}示例代码2：
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
vector<long long> numList;
int main(){
int n;
long long inputNumber;
while(cin >> n){
numList.clear();
for(int i = 0; i < n; i++){
cin >> inputNumber;
numList.push_back(inputNumber);
}
sort(numList.begin(), numList.end());
long long result = 0;
if(numList[n - 1] <= 0){
int i = n - 1;
while(i >= 0 && numList[n - 1] == 0){
i--;
}
if(i >= 2){
result = numList[i] * numList[i - 1] * numList[i - 2];
}
}else{
long long result1 = numList[n - 1] * numList[n - 2] * numList[n - 3];
long long result2 = numList[0] * numList[1] * numList[n - 1];
result = max(result1, result2);
}
cout << result << endl;
}
return 0;
}4、题目描述：给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1），每段绳子的长度记为k[0],k[1],...,k[m]。请问k[0]xk[1]x...xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。【剑指Offer_编程题】
- 输入格式：输入一个数n，意义见题面。（2 <= n <= 60）
- 输出格式：输出答案。
- 样例输入：
- 8
- 样例输出：
- 18
示例代码：
class Solution {
public:
int cutRope(int number) {
if(number == 2){
return 1;
}else{
int split = (int)round(sqrt(number));
int result = 1;
int sub = number / split;
int count = number - split * sub;
while(number > 0){
if(count > 0){
result *= (sub + 1);
number -= (sub + 1);
count--;
}else{
result *= sub;
number -= sub;
}
}
return result;
}
}
};5、题目描述：有一个长为n的数组A，求满足0≤a≤b<n的A[b]-A[a]的最大值。给定数组A及它的大小n，请返回最大差值。
int getDis(vector<int> A, int n) {
// write code here
}【美团】
- 输入格式：数组A以及它的大小n
- 输出格式：返回最大差值
- 样例输入：
- [10,5],2
- 样例输出：
- 0
示例代码：
class LongestDistance {
public:
int getDis(vector<int> A, int n){
vector<int> dp(n); //记录该元素之前的最小值
vector<int> result(n); //记录最大差值
dp[0] = A[0];
result[0] = 0;
for(int i = 1; i < n; i++){
if(A[i] >= dp[i - 1]){
result[i] = A[i] - dp[i - 1];
dp[i] = dp[i - 1];
}else{
dp[i] = A[i];
result[i] = 0;
}
}
int maxValue = result[0];
for(int i = 0; i < n; i++){
cout << result[i] << endl;
maxValue = max(maxValue, result[i]);
}
return maxValue;
}
};6、题目描述：小易有一个古老的游戏机，上面有着经典的游戏俄罗斯方块。因为它比较古老，所以规则和一般的俄罗斯方块不同。荧幕上一共有 n 列，每次都会有一个 1 x 1 的方块随机落下，在同一列中，后落下的方块会叠在先前的方块之上，当一整行方块都被占满时，这一行会被消去，并得到1分。有一天，小易又开了一局游戏，当玩到第 m 个方块落下时他觉得太无聊就关掉了，小易希望你告诉他这局游戏他获得的分数。【网易】
- 输入格式：第一行两个数 n, m，第二行 m 个数，c1, c2, ... , cm ， ci 表示第 i 个方块落在第几列。其中 1 <= n, m <= 1000, 1 <= ci <= n
- 输出格式：小易这局游戏获得的分数
- 样例输入：
- 3 9
- 1 1 2 2 2 3 1 2 3
- 样例输出：
- 2
示例代码：
#include <iostream>
#include <vector>
using namespace std;
int main(){
int n, m;
while(cin >> n >> m){
vector<int> column(n + 1);
int inputNumber;
for(int i = 0; i < m; i++){
cin >> inputNumber;
column[inputNumber]++;
}
int minValue = column[1];
for(int i = 1; i <= n; i++){
minValue = min(minValue, column[i]);
}
cout << minValue << endl;
}
return 0;
}7、题目描述：n 只奶牛坐在一排，每个奶牛拥有 ai 个苹果，现在你要在它们之间转移苹果，使得最后所有奶牛拥有的苹果数都相同，每一次，你只能从一只奶牛身上拿走恰好两个苹果到另一个奶牛上，问最少需要移动多少次可以平分苹果，如果方案不存在输出 -1。【网易】
- 输入格式：每个输入包含一个测试用例。每个测试用例的第一行包含一个整数 n（1 <= n <= 100），接下来的一行包含 n 个整数 ai（1 <= ai <= 100）。
- 输出格式：输出一行表示最少需要移动多少次可以平分苹果，如果方案不存在则输出 -1。
- 样例输入：
- 4
- 7 15 9 5
- 样例输出：
- 3
示例代码：
#include <iostream>
#include <vector>
using namespace std;
vector<int> nodeList;
int main(){
int n;
while(cin >> n){
int inputNumber, total = 0;
for(int i = 0; i < n; i++){
cin >> inputNumber;
total += inputNumber;
nodeList.push_back(inputNumber);
}
int result = 0;
if(total % n != 0){
result = -1;
}else{
int avg = total / n;
bool flag = true;
for(int i = 0; i < n; i++){
if(nodeList[i] > avg){
if((nodeList[i] - avg) % 2 != 0){
result = -1;
break;
}else{
result += (nodeList[i] - avg) / 2;
}
}
}
}
cout << result << endl;
}
return 0;
}8、题目描述：如果一个数字序列逆置之后跟原序列是一样的就称这样的数字序列为回文序列。例如：{1, 2, 1}, {15, 78, 78, 15} , {112} 是回文序列,{1, 2, 2}, {15, 78, 87, 51} ,{112, 2, 11} 不是回文序列。现在给出一个数字序列，允许使用一种转换操作：选择任意两个相邻的数，然后从序列移除这两个数，并用这两个数字的和插入到这两个数之前的位置(只插入一个和)。现在对于所给序列要求出最少需要多少次操作可以将其变成回文序列。【网易】
- 输入格式：输入为两行，第一行为序列长度n ( 1 ≤ n ≤ 50) 第二行为序列中的n个整数item[i] (1 ≤ item[i] ≤ 1000)，以空格分隔。
- 输出格式：输出一个数，表示最少需要的转换次数
- 样例输入：
- 4
- 1 1 1 3
- 样例输出：
- 2
示例代码：
#include <iostream>
#include <deque>
using namespace std;
deque<int> myQueue;
int main(){
int n, inputNumber;
while(cin >> n){
for(int i = 0; i < n; i++){
cin >> inputNumber;
myQueue.push_back(inputNumber);
}
int result = 0;
while(!myQueue.empty()){
if(myQueue.size() == 1){
myQueue.pop_back();
continue;
}
if(myQueue.front() == myQueue.back()){
myQueue.pop_back();
myQueue.pop_front();
}else{
if(myQueue.front() > myQueue.back()){
int a = myQueue.back();
myQueue.pop_back();
a += myQueue.back();
myQueue.pop_back();
myQueue.push_back(a);
}else{
int a = myQueue.front();
myQueue.pop_front();
a += myQueue.front();
myQueue.pop_front();
myQueue.push_front(a);
}
result++;
}
}
cout << result << endl;
}
return 0;
}9、题目描述：六一儿童节，老师带了很多好吃的巧克力到幼儿园。每块巧克力j的重量为w[j]，对于每个小朋友i，当他分到的巧克力大小达到h[i] (即w[j]>=h[i])，他才会上去表演节目。老师的目标是将巧克力分发给孩子们，使得最多的小孩上台表演。可以保证每个w[i]> 0且不能将多块巧克力分给一个孩子或将一块分给多个孩子。【拼多多】
- 输入格式：第一行：n，表示h数组元素个数。第二行：n个h数组元素。第三行：m，表示w数组元素个数。第四行：m个w数组元素。
- 输出格式：上台表演学生人数
- 样例输入：
- 3
- 2 2 3
- 2
- 3 1
- 样例输出：
- 1
示例代码：
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
vector<double> childList;
vector<double> chocoList;
int main(){
int inputNumber, n, m;
while(cin >> n){
for(int i = 0; i < n; i++){
cin >> inputNumber;
childList.push_back(inputNumber);
}
sort(childList.begin(), childList.end());
cin >> m;
for(int i = 0; i < m; i++){
cin >> inputNumber;
chocoList.push_back(inputNumber);
}
sort(chocoList.begin(), chocoList.end());
int index = 0, result = 0;
for(int i = 0; i < chocoList.size(); i++){
for(int j = index; j < childList.size(); j++){
if(chocoList[i] >= childList[j]){
result++;
index = j + 1;
break;
}
}
}
cout << result << endl;
}
return 0;
}10、题目描述：给定一个十进制的正整数number，选择从里面去掉一部分数字，希望保留下来的数字组成的正整数最大。【搜狐】
- 输入格式：输入为两行内容，第一行是正整数number，1 ≤ length(number) ≤ 50000。第二行是希望去掉的数字数量cnt 1 ≤ cnt < length(number)。
- 输出格式：输出保留下来的结果。
- 样例输入：
- 325 1
- 样例输出：
- 35
示例代码：
#include <iostream>
#include <string>
using namespace std;
int main(){
string s;
int n;
while(cin >> s >> n){
bool flag1 = true;
while(n > 0){
if(flag1){
flag1 = false;
for(int i = 0; i < s.size() - 1; i++){
if(s[i] < s[i + 1]){
flag1 = true;
s.erase(s.begin() + i);
n--;
break;
}
}
}else{
s.erase(s.end() - 1);
n--;
}
}
cout << s << endl;
}
return 0;
}11、题目描述：输入一个正整数n,求n!(即阶乘)末尾有多少个0？ 比如: n = 10; n! = 3628800,所以答案为2【滴滴】
- 输入格式：输入为一行，n(1 ≤ n ≤ 1000)
- 输出格式：输出一个整数,即题目所求
- 样例输入：
- 10
- 样例输出：
- 2
示例代码1：
#include <iostream>
using namespace std;
int main(){
int n;
while(cin >> n){
int result = 0;
for(int i = 5; i <= n; i += 5){
int tmp = i;
while(tmp % 5 == 0){
result++;
tmp /= 5;
}
}
cout << result << endl;
}
return 0;
}示例代码2：
#include <iostream>
using namespace std;
int main(){
int n;
while(cin >> n){
int result = 0;
while(n){
result += n / 5;
n /= 5;
}
cout << result << endl;
}
return 0;
}12、题目描述：小易觉得高数课太无聊了，决定睡觉。不过他对课上的一些内容挺感兴趣，所以希望你在老师讲到有趣的部分的时候叫醒他一下。你知道了小易对一堂课每分钟知识点的感兴趣程度，并以分数量化，以及他在这堂课上每分钟是否会睡着，你可以叫醒他一次，这会使得他在接下来的k分钟内保持清醒。你需要选择一种方案最大化小易这堂课听到的知识点分值。【网易】
- 输入格式：第一行 n, k (1 <= n, k <= 105) ，表示这堂课持续多少分钟，以及叫醒小易一次使他能够保持清醒的时间。第二行 n 个数，a1, a2, ... , an(1 <= ai <= 104) 表示小易对每分钟知识点的感兴趣评分。第三行 n 个数，t1, t2, ... , tn 表示每分钟小易是否清醒, 1表示清醒。
- 输出格式：小易这堂课听到的知识点的最大兴趣值。
- 样例输入：
- 6 3
- 1 3 5 2 5 4
- 1 1 0 1 0 0
- 样例输出：
- 16
示例代码：
#include <iostream>
#include <vector>
using namespace std;
vector<int> interest;
vector<int> sleep;
int main(){
int n, k;
while(cin >> n >> k){
int inputNum;
interest.clear();
sleep.clear();
for(int i = 0; i < n; i++){
cin >> inputNum;
interest.push_back(inputNum);
}
for(int i = 0; i < n; i++){
cin >> inputNum;
sleep.push_back(inputNum);
}
int result = 0, increaseValue = 0;
for(int i = 0; i <= n - k; i++){
if(sleep[i] == 0 || i == n - k){
int tmp = 0;
for(int j = i; j < i + k; j++){
if(sleep[j] == 0){
tmp += interest[j];
}
}
increaseValue = max(increaseValue, tmp);
}
}
for(int i = 0; i < n; i++){
if(sleep[i] == 1){
result += interest[i];
}
}
cout << result + increaseValue << endl;
}
return 0;
}13、题目描述：There are N gas stations along a circular route, where the amount of gas at station i is gas[i].You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.Return the starting gas station's index if you can travel around the circuit once, otherwise return -1.
Note: The solution is guaranteed to be unique.
int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
//write code here
}【LeetCode】
- 输入格式：
- 输出格式：
- 样例输入：
- 样例输出：
示例代码：
class Solution {
public:
int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
int start = 0, end = gas.size() - 1;
int currentGas = gas[end] - cost[end];
while(start < end){
if(currentGas >= 0){
currentGas += gas[start] - cost[start];
start++;
}else{
end--;
currentGas += gas[end] - cost[end];
}
}
if(currentGas >= 0){
return start;
}else{
return -1;
}
}
};14、题目描述：度度熊有一张网格纸，但是纸上有一些点过的点，每个点都在网格点上，若把网格看成一个坐标轴平行于网格线的坐标系的话，每个点可以用一对整数x，y来表示。度度熊必须沿着网格线画一个正方形，使所有点在正方形的内部或者边界。然后把这个正方形剪下来。问剪掉正方形的最小面积是多少。【百度】
- 输入格式：第一行一个数n(2≤n≤1000)表示点数，接下来每行一对整数xi,yi(－1e9<=xi,yi<=1e9)表示网格上的点
- 输出格式：一行输出最小面积
- 样例输入：
- 2
- 0 0
- 0 3
- 样例输出：
- 9
示例代码：
#include <iostream>
using namespace std;
int main(){
int n;
long long x, y;
while(cin >> n){
long long maxX = 0, maxY = 0, minX = 0, minY = 0;
for(int i = 0; i < n; i++){
cin >> x >> y;
if(x > 0){
maxX = max(x, maxX);
}else{
minX = min(x, minX);
}
if(y > 0){
maxY = max(y, maxY);
}else{
minY = min(y, minY);
}
}
long long maxValue = max((maxY - minY), (maxX - minX));
cout << maxValue * maxValue << endl;
}
return 0;
}15、题目描述：某餐馆有n张桌子，每张桌子有一个参数：a 可容纳的最大人数； 有m批客人，每批客人有两个参数:b人数，c预计消费金额。 在不允许拼桌的情况下，请实现一个算法选择其中一部分客人，使得总预计消费金额最大【滴滴】
- 输入格式：c输入包括m+2行。 第一行两个整数n(1 <= n <= 50000),m(1 <= m <= 50000) 。第二行为n个参数a,即每个桌子可容纳的最大人数,以空格分隔,范围均在32位int范围内。 接下来m行，每行两个参数b,c。分别表示第i批客人的人数和预计消费金额,以空格分隔,范围均在32位int范围内。
- 输出格式：输出一个整数,表示最大的总预计消费金额
- 样例输入：
- 3 5
- 2 4 2
- 1 3
- 3 5
- 3 7
- 5 9
- 1 10
- 样例输出：
- 20
示例代码：
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
struct Node{
int people;
int money;
Node(int p, int m):people(p), money(m){};
bool operator<(const Node &n)const{
if(money == n.money){
return people < n.people;
}
return money < n.money;
};
};
vector<int> tableList;
priority_queue<Node> nodeList;
int CompareAsc(int x, int y){
return x < y;
}
int main(){
int n, m, inputNum, people, money;
while(cin >> n >> m){
tableList.clear();
for(int i = 0; i < n; i++){
cin >> inputNum;
tableList.push_back(inputNum);
}
for(int i = 0; i < m; i++){
cin >> people >> money;
nodeList.push(Node(people, money));
}
sort(tableList.begin(), tableList.end(), CompareAsc);
long long result = 0;
while(tableList.size() > 0 && !nodeList.empty()){
Node node = nodeList.top();
nodeList.pop();
for(int i = 0; i < tableList.size(); i++){
if(tableList[tableList.size() - 1] < node.people){
break;
}
if(tableList[i] >= node.people){
tableList.erase(tableList.begin() + i);
result += node.money;
break;
}
}
}
cout << result << endl;
}
return 0;
}
2990
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
