目录
一，泛背包问题
这一类贪心问题里面有点类似背包问题，但并不是真正的背包问题。
背包九讲，个个不贪心。
CSU 1775 悲催的移寝
题目：
对于csuxushu来说，能够在CSU（California State University）上学是他一生的荣幸，而换校区搬寝室则是他最大的不幸。顺利通过省赛选拔，开心的csuxushu现在需要着手准备搬家事宜。
对于好学的csuxushu来说，唯一头疼的就是书籍的搬运了，因为他的书实在是太多了。为了防止书籍在运输过程中受损，他打算定制特制的储物保护箱。为了简单起见，我们假设他所有的书都是一样规格。由于是批量定制，这些储物箱都有相同的长度L，宽度和厚度都是一本书的宽度和厚度。csuxushu有一个特殊的要求，那就是每个储物箱最多只能放两本书。当然，他需要运走所有的N本书，并且每一个储物箱里书的总长度不能超过L。
尽管校队队员给了csuxushu许多奖励，csuxushu还是想定尽可能少的储物箱，以求节约经费，然而面对这么困难的问题他显然是一脸懵逼，这时候他想到了你——全CSU最厉害的程序员来帮助他解决这个问题。
第一行一个整数T，代表有T组数据，之后一个空行并且接下来每两组数据之间有一个空行。
每组数据第一行，为1个整数n (1 ≤ n ≤ 10^5)，代表有n本书。第二行，为1个整数L ，1≤l ≤ 10000 ，为特制储物箱长度。接下来n行，分别为每本书的长度li，li≤l。
每组数据输出一行，即csuxushu至少需要定多少储物箱。
1
10
80
70
15
30
35
10
80
20
35
10
30
6
这个题目也是挺坑的，需要的输出格式是2个数之间还有一个空行。
这个题目就是先排序后用贪心算法，虽然很难说清楚，不过算法应该是对的。
代码：
#include<iostream>
#include<algorithm>
using namespace std;
int list[100000];
int main()
{
int t, n, l;
int low, high;
int sum;
cin >> t;
for (int ii = 0; ii < t;ii++)
{
cin >> n >> l;
for (int i = 0; i < n; i++)cin >> list[i];
sort(list, list + n);
low = 0;
high = n - 1;
sum = 0;
while (low < high)
{
if (list[low] + list[high] <= l)low++;
high--;
sum++;
}
if (low == high)sum++;
cout << sum << endl<<endl;
}
return 0;
}CodeForces 538B Quasi Binary
题目：
Description
A number is called quasibinary if its decimal representation contains only digits 0 or 1. For example, numbers 0, 1, 101, 110011 — are quasibinary and numbers 2, 12, 900 are not.
You are given a positive integer n. Represent it as a sum of minimum number of quasibinary numbers.
Input
The first line contains a single integer n (1 ≤ n ≤ 106).
Output
In the first line print a single integer k — the minimum number of numbers in the representation of number n as a sum of quasibinary numbers.
In the second line print k numbers — the elements of the sum. All these numbers should be quasibinary according to the definition above, their sum should equal n. Do not have to print the leading zeroes in the numbers. The order of numbers doesn't matter. If there are multiple possible representations, you are allowed to print any of them.
Sample Input
Input
9
Output
9 1 1 1 1 1 1 1 1 1
Input
32
Output
3 10 11 11
这个题目，首先要明确一点，不管输入的数是多少，我们所求的那些数加起来等于这个数，在加起来的过程中，绝对不会出现任何的进位现象。
要说证明的话倒也不难，不过应该是没有必要的。
总之，利用这个性质就可以轻松求解了。
代码：
#include<iostream>
#include<stack>
using namespace std;
stack<int>s;
int ff(int a, int b, int c, int d, int e, int f)
{
int min = 10;
if (a > 0 && min > a)min = a;
if (b > 0 && min > b)min = b;
if (c > 0 && min > c)min = c;
if (d > 0 && min > d)min = d;
if (e > 0 && min > e)min = e;
if (f > 0 && min > f)min = f;
if (min == 10)return 0;
int x = (a >= min) * 100000 + (b >= min) * 10000 + (c >= min) * 1000 + (d >= min) * 100 + (e >= min) * 10 + (f >= min);
for (int i = 0; i < min; i++)s.push(x);
return ff(a - (a >= min)*min, b - (b >= min)*min, c - (c >= min)*min, d - (d >= min)*min, e - (e >= min)*min, f - (f >= min)*min) + min;
}
int main()
{
int n;
cin >> n;
int a, b, c, d, e, f;
if (n == 1000000)cout << 1 << endl << 1000000;
else
{
f = n % 10;
e = n / 10 % 10;
d = n / 100 % 10;
c = n / 1000 % 10;
b = n / 10000 % 10;
a = n / 100000;
cout << ff(a, b, c, d, e, f) << endl;
while (!s.empty())
{
cout << s.top() << " ";
s.pop();
}
}
return 0;
}当然，仔细想一想的话，本题是不需要栈的。
代码：
#include<iostream>
#include<stack>
using namespace std;
void ff(int a, int b, int c, int d, int e, int f)
{
int s = 0;
if (a + b + c + d + e + f == 0)return;
if (f)
{
f--;
s += 1;
}
if (e)
{
e--;
s += 10;
}
if (d)
{
d--;
s += 100;
}
if (c)
{
c--;
s += 1000;
}
if (b)
{
b--;
s += 10000;
}
if (a)
{
a--;
s += 100000;
}
cout << s << " ";
ff(a, b, c, d, e, f);
}
int main()
{
int n;
cin >> n;
int a, b, c, d, e, f;
if (n == 1000000)cout << 1 << endl << 1000000;
else
{
f = n % 10;
e = n / 10 % 10;
d = n / 100 % 10;
c = n / 1000 % 10;
b = n / 10000 % 10;
a = n / 100000;
int max = 0;
if (max < a)max = a;
if (max < b)max = b;
if (max < c)max = c;
if (max < d)max = d;
if (max < e)max = e;
if (max < f)max = f;
cout << max << endl;
ff(a, b, c, d, e, f);
cout << endl;
}
return 0;
}这个代码看起来就要简单好多。
其实差别不大，但是这个代码更明显的体现了一种贪心策略：
每次都输出一个数，使得它有尽可能的1，当然了，要是满足题目的条件的数。
二，择路问题
有2个很常见的择路问题
（1）商场中找WC
商场中找WC，经常会遇到这样的场景
用尽量标准的语言来描述是：
两个指示牌不明显一致，也不明显矛盾，只能说存在一致的可能性。
实际上的全景图可能是这种：
根据我多年的经验，选择最近的路，有更大的概率更快找到WC，有更大概率走更短的路找到WC。
上图是随手画的，本着严谨的态度，经过测量，下面的路总长46毫米，上面的路总长49毫米。
（2）满堂悦神秘事件——消失的11号楼
为什么从北门往南走的时候总是经过11号楼，而每次我从家里出发去找11号楼都找到10号楼去了？
经过我仔细分析，大概是这么回事：
对于这种无指示牌的场景，我的择路原则是：
选择方向最接近目的地的那条路。
于是，我每次往北走和往南走都是不同的路线（上南下北）
我画了6个箭头，往北走3个，往南走3个。
这叫基本上能解释，为什么往南走的时候总是经过11号楼，而每次我从家里出发去找11号楼都找不到。
总结：
这2个例子很具有代表性，第一个是商场，商场的指示牌一般都比较科学，按照贪心原理可以找到全局最优解，因为指示牌就是基于全局路线规划的，第二个是小区，小区里面没有指示牌，怎么走凭感觉，根据贪心原理找不到全局最优解。
三，多机调度问题
多机调度问题是NP问题，用贪心算法可以求近似最优解
【问题描述】要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成 。约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。作业不能拆分成更小的子作业。
#include<iostream>
using namespace std;
int getMinIndex(int *p, int m)
{
int index = 0;
int min = p[0];
for (int i = 1; i < m; i++)
{
if (min > p[i])
{
min = p[i];
index = i;
}
}
return index;
}
int main()
{
int n, m;
cout << "输入n,m,n个时间\n";
cin >> n >> m;
vector<int>list(n);
for (int i = 0; i < n; i++)
{
cin >> list[i];
}
sort(list.begin(),list.end());
int *p = new int[m]; //m上的进程时间和
vector<vector<int>>result;
for (int i = 0; i < m; i++)
{
p[i] = 0;
}
result.resize(m);
for (int i = n - 1; i >= 0; i--)
{
int index = getMinIndex(p, m);
result[index].push_back(list[i]);
p[index] += list[i];
}
for (int i = 0; i < m; i++)
{
cout << endl;
for (int j = 0; j < result[i].size(); j++)
{
cout << result[i][j] << " ";
}
}
system("pause>nul");
return 0;
}
输入：
7 3
2 14 4 16 6 5 3
输出：
16
14 3
6 5 4 2
四，其他贪心问题
CSU 1410 整数转换
题目：
Description
我们可以通过对一个整数 A 进行加1操作或者乘2操作使其转换为另一个整数 B 。
给出两个整数 X , Y ，计算至少需要多少步才能将 X 转换为 Y 。 .
Input
输入的第一行包含一个整数 T (1 ≤ T ≤ 5 00 )，表示一共有 T 组测试数据。
每组测试数据占一行，包含两个整数 X , Y (1 ≤ X ≤ Y ≤ 10 18 )。
Output
对于每组测试数据，输出至少需要多少步才能将 X 转换为 Y 。
Sample Input
3
1 1
3 10
2 11
Sample Output
0
3
4
代码：
#include<iostream>
using namespace std;
int main()
{
int t;
long long x, y;
cin >> t;
while (t--)
{
cin >> x >> y;
long long ans = 0;
while (y > x)
{
if (y < x * 2)
{
ans += y - x;
break;
}
if (y % 2 == 0)y /= 2;
else y--;
ans++;
}
cout << ans << endl;
}
return 0;
}CSU 1588 合并果子
题目：
Description
现在有n堆果子，第i堆有ai个果子。现在要把这些果子合并成一堆，每次合并的代价是两堆果子的总果子数。求合并所有果子的最小代价。
Input
第一行包含一个整数T（T<=50），表示数据组数。
每组数据第一行包含一个整数n（2<=n<=1000），表示果子的堆数。
第二行包含n个正整数ai（ai<=100），表示每堆果子的果子数。
Output
每组数据仅一行，表示最小合并代价。
Sample Input
2
4
1 2 3 4
5
3 5 2 1 4
Sample Output
19
33
如果只能合并相邻的那就是区间DP，参考 CSU 1592 石子归并
本题是贪心，每次选取最小的2个合并，和哈夫曼编码差不多
代码：
#include<iostream>
#include<queue>
using namespace std;
int main()
{
int t, n, num;
priority_queue<int>q;
cin >> t;
while (t--)
{
while (!q.empty())q.pop();
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> num;
q.push(-num);
}
int ans = 0, a, b;
while (q.size() > 1)
{
a = q.top();
q.pop();
b = q.top();
q.pop();
ans += a + b;
q.push(a + b);
}
cout << -ans << endl;
}
return 0;
}HDU 1257 最少拦截系统
题目：
Description
某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统.但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能超过前一发的高度.某天,雷达捕捉到敌国的导弹来袭.由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹.
怎么办呢?多搞几套系统呗!你说说倒蛮容易,成本呢?成本是个大问题啊.所以俺就到这里来求救了,请帮助计算一下最少需要多少套拦截系统.
Input
输入若干组数据.每组数据包括:导弹总个数(正整数),导弹依此飞来的高度(雷达给出的高度数据是不大于30000的正整数,用空格分隔)
Output
对应每组数据输出拦截所有导弹最少要配备多少套这种导弹拦截系统.
Sample Input
8 389 207 155 300 299 170 158 65Sample Output
2
这是一个贪心的问题。
贪心策略：每次选择一个系统来拦截炮弹的时候，选择可以满足条件的所有系统中，高度最小的系统。
也就是尽量减小浪费的意思。
代码：
#include<iostream>
using namespace std;
int l[30000];
int main()
{
int n, k, sum;
while (cin >> n)
{
for (int i = 0; i < 30000; i++)l[i] = 30001;
while (n--)
{
cin >> k;
for (int i = 0; i < 30000; i++)if (l[i] >= k)
{
l[i] = k;
break;
}
}
sum = 0;
for (int i = 0; i < 30000; i++)sum += (l[i] < 30001);
cout << sum << endl;
}
return 0;
}HDU 5835 Danganronpa
题目：
Description
Chisa Yukizome works as a teacher in the school. She prepares many gifts, which consist of kinds with quantities of each kind, for her students and wants to hold a class meeting. Because of the busy work, she gives her gifts to the monitor, Chiaki Nanami. Due to the strange design of the school, the students' desks are in a row. Chiaki Nanami wants to arrange gifts like this:
1. Each table will be prepared for a mysterious gift and an ordinary gift.
2. In order to reflect the Chisa Yukizome's generosity, the kinds of the ordinary gift on the adjacent table must be different.
3. There are no limits for the mysterious gift.
4. The gift must be placed continuously.
She wants to know how many students can get gifts in accordance with her idea at most (Suppose the number of students are infinite). As the most important people of her, you are easy to solve it, aren't you?
Input
The first line of input contains an integer indicating the number of test cases.
Each case contains one integer . The next line contains numbers: , .
Output
For each test case, output one line containing “Case #x: y” (without quotes) , where x is the test case number (starting from 1) and y is the answer of Chiaki Nanami's question.
Sample Input
1
2
3 2
Sample Output
Case #1: 2
这个题目的意思是给出若干个数，比如本题2个数：3,2
每个数代表1种不同的球的个数，现在问你，最多能选出多少个，使得他们可以排成一排，相邻的球都不同。
比如本题，3个a，2个b可以排成ababa，答案应该是5。
但是本题有个限制，不想细说，总之就是如果这么算出来超过了sum的一半，那么答案就是sum的一半。
sum就是这若干个数的和，max就是这若干个数的最大值。
对于一般的若干个数，能如上排成一排其实就等价于max<=sum-max+1
也就是说，对于2,3,6，max=6,sum=11,刚好满足max=sum-max+1，那么2个a，3个b，6个c可以排成cacacbcbcbc
对于2,3,7，max=7,sum=12,不满足max<=sum-max+1,那么它们无论怎么排，都不满足条件。
所以现在就是要求，对于输入的若干个数，每个数可以变成不超过它的另外一个整数，
最后需要满足max<=sum-max+1，求sum的最大值。
其实这个问题很好求解，可以理解为贪心（真的是有够贪心）
首先排序，增序，然后前面所有的数都不变，最后一个数在满足max<=sum-max+1的情况下尽可能取最大。
就这样，没了，是的，没了。
代码：
#include<iostream>
#include<algorithm>
using namespace std;
int list[10];
int main()
{
int t, n, sum, s;
cin >> t;
for (int i = 1; i <= t;i++)
{
cin >> n;
sum = 0;
for (int i = 0; i < n; i++)
{
cin >> list[i];
sum += list[i];
}
sum /= 2;
sort(list, list + n);
s = 0;
for (int i = 0; i < n - 1; i++)s += list[i];
if (list[n-1] <= s + 1)s += list[n-1];
else s += s + 1;
if (s>sum)s = sum;
printf("Case #%d: %d\n", i, s);
}
return 0;
}CSU 1903 Tricky数
题目：
Description
小A很喜欢对着别人”233”，然后他发现有很多数字可以提取出他喜欢的233的子序列。于是乎自以为是的他决定自己定义一种Tricky数，这种数字在不重复利用每一位的条件下，可以提取出k(k>0)个子序列，而且保证提取出这k个子序列都是”233”,且不再剩余任何数字。
子序列：某个序列的子序列是从最初序列中任意取出一些元素，在不破坏原始的顺序基础上排成的序列。
Input
第一行输入一个正整数T，表示数据组数 T<=1000 每组数据一行输入一个数字v(0<v<=10^1000)
Output
对于每组数据如果v是Tricky数，输出”Yes” , 否则输出”No”
Sample Input
2
232333
233323
Sample Output
Yes
No
直接从左往右扫描，更新2的数量和3的数量即可
我在比赛时候提交的代码：
#include<iostream>
#include<string.h>
using namespace std;
char c[1005];
bool ok()
{
int len=strlen(c);
int n2=0,n3=0;
for(int i=0;i<len;i++)
{
if(c[i]=='2')n2++;
if(c[i]=='3')n3++;
}
if(n3!=n2*2)return false;
if(len!=n2*3)return false;
n2=0,n3=0;
int s=0;
for(int i=0;i<len;i++)
{
if(c[i]=='2')s+=2;
if(c[i]=='3')s--;
if(s<0)return false;
}
return true;
}
int main()
{
int T;
cin>>T;
while(T--)
{
scanf("%s",&c);
if(ok())cout<<"Yes\n";
else cout<<"No\n";
}
return 0;
}ok函数可以化简成：
bool ok()
{
int len = strlen(c),s = 0;
for (int i = 0; i<len; i++)
{
if (c[i] == '2')s += 2;
if (c[i] == '3')s--;
if (s<0)return false;
}
return s==0;
}力扣 843. 猜猜这个单词
给你一个由 不同 字符串组成的单词列表 words ，其中 words[i] 长度均为 6 。words 中的一个单词将被选作秘密单词 secret 。
另给你一个辅助对象 Master ，你可以调用 Master.guess(word) 来猜单词，其中参数 word 长度为 6 且必须是 words 中的字符串。
Master.guess(word) 将会返回如下结果：
- 如果
word不是words中的字符串，返回-1，或者 - 一个整数，表示你所猜测的单词
word与 秘密单词secret的准确匹配（值和位置同时匹配）的数目。
每组测试用例都会包含一个参数 allowedGuesses ，其中 allowedGuesses 是你可以调用 Master.guess(word) 的最大次数。
对于每组测试用例，在不超过允许猜测的次数的前提下，你应该调用 Master.guess 来猜出秘密单词。最终，你将会得到以下结果：
- 如果你调用
Master.guess的次数大于allowedGuesses所限定的次数或者你没有用Master.guess猜到秘密单词，则得到"Either you took too many guesses, or you did not find the secret word."。 - 如果你调用
Master.guess猜到秘密单词，且调用Master.guess的次数小于或等于allowedGuesses，则得到"You guessed the secret word correctly."。
生成的测试用例保证你可以利用某种合理的策略（而不是暴力）猜到秘密单词。
示例 1：
输入：secret = "acckzz", words = ["acckzz","ccbazz","eiowzz","abcczz"], allowedGuesses = 10
输出：You guessed the secret word correctly.
解释：
master.guess("aaaaaa") 返回 -1 ，因为 "aaaaaa" 不在 words 中。
master.guess("acckzz") 返回 6 ，因为 "acckzz" 是秘密单词 secret ，共有 6 个字母匹配。
master.guess("ccbazz") 返回 3 ，因为 "ccbazz" 共有 3 个字母匹配。
master.guess("eiowzz") 返回 2 ，因为 "eiowzz" 共有 2 个字母匹配。
master.guess("abcczz") 返回 4 ，因为 "abcczz" 共有 4 个字母匹配。
一共调用 5 次 master.guess ，其中一个为秘密单词，所以通过测试用例。
示例 2：
输入：secret = "hamada", words = ["hamada","khaled"], allowedGuesses = 10 输出：You guessed the secret word correctly. 解释：共有 2 个单词，且其中一个为秘密单词，可以通过测试用例。
提示：
1 <= words.length <= 100words[i].length == 6words[i]仅由小写英文字母组成words中所有字符串 互不相同secret存在于words中10 <= allowedGuesses <= 30
思路：
我采用的是贪心的思路，其实这不能得到最优解，只能得到近似最优解。
贪心策略就是尽量保证每种情况下的数量是均衡的，达成分治的效果。
/*
class Master {
public:
Master(string s) {
this->s = s;
}
string s;
int guess(string word) {
return sameNum(s, word);
}
int sameNum(string &s1, string &s2) {
int s = 0;
for (int i = 0; i < 6; i++)if (s1[i] == s2[i])s++;
return s;
}
};
*/
class Solution {
public:
void findSecretWord(vector<string>& words, Master& master) {
while (words.size() > 1) {
int id = 0, mins = maxGroupNum(words, words[0]);
for (int i = 1; i < words.size(); i++) {
if (mins > maxGroupNum(words, words[i]))id = i;
}
int num = master.guess(words[id]);
vector<string> v;
for (auto &si : words)if (sameNum(si, words[id]) == num)v.push_back(si);
words = v;
}
master.guess(words[0]);
}
int maxGroupNum(vector<string>& words, string &s)
{
vector<int>v(7);
for (auto &si : words)v[sameNum(si, s)]++;
int ans = 0;
for (int i = 0; i < 6; i++)ans = max(ans, v[i]);
return ans;
}
int sameNum(string &s1, string &s2) {
int s = 0;
for (int i = 0; i < 6; i++)if (s1[i] == s2[i])s++;
return s;
}
};力扣 2789. 合并后数组中的最大元素
给你一个下标从 0 开始、由正整数组成的数组 nums 。
你可以在数组上执行下述操作 任意 次：
- 选中一个同时满足
0 <= i < nums.length - 1和nums[i] <= nums[i + 1]的整数i。将元素nums[i + 1]替换为nums[i] + nums[i + 1]，并从数组中删除元素nums[i]。
返回你可以从最终数组中获得的 最大 元素的值。
示例 1：
输入：nums = [2,3,7,9,3] 输出：21 解释：我们可以在数组上执行下述操作： - 选中 i = 0 ，得到数组 nums = [5,7,9,3] 。 - 选中 i = 1 ，得到数组 nums = [5,16,3] 。 - 选中 i = 0 ，得到数组 nums = [21,3] 。 最终数组中的最大元素是 21 。可以证明我们无法获得更大的元素。
示例 2：
输入：nums = [5,3,3] 输出：11 解释：我们可以在数组上执行下述操作： - 选中 i = 1 ，得到数组 nums = [5,6] 。 - 选中 i = 0 ，得到数组 nums = [11] 。 最终数组中只有一个元素，即 11 。
提示：
1 <= nums.length <= 1051 <= nums[i] <= 106
class Solution {
public:
long long maxArrayValue(vector<int>& nums) {
long long ans = 0, m = 0;
for (int i = nums.size() - 1; i >= 0; i--) {
if (nums[i] > m)ans = max(ans, m), m = nums[i];
else m += nums[i];
}
return max(ans, m);
}
};
1278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
