目录
HDU1053——Entropy
题目描述
问题描述：熵编码器是一种数据编码方法，通过去除消息中“浪费”或“多余”的信息来实现无损数据压缩。换句话说，熵编码会去除一开始对于准确编码消息并非必要的信息。高度的熵意味着消息有大量浪费的信息；用 ASCII 编码的英文文本就是具有很高熵的消息类型的一个例子。已经压缩过的消息，如 JPEG 图形或 ZIP 存档，具有很少的熵，并且不会从进一步的熵编码尝试中受益。
用 ASCII 编码的英文文本具有高熵度，因为所有字符都使用相同数量的位（8 位）进行编码。众所周知，在英文文本中，字母 E、L、N、R、S 和 T 的出现频率远高于大多数其他字母。如果能找到一种方法仅用 4 位来编码这些字母，那么新的编码将会更小，包含所有原始信息，并且具有更低的熵。然而，ASCII 使用固定数量的位是有原因的：它很简单，因为总是处理固定数量的位来表示每个可能的字形或字符。对于上述字母使用 4 位的编码方案如何能够区分 4 位代码和 8 位代码？这个看似困难的问题通过使用所谓的“无前缀可变长度”编码来解决。
在这种编码中，可以使用任意数量的位来表示任何字形，并且消息中不存在的字形根本不进行编码。但是，为了能够恢复信息，任何编码字形的位模式都不允许是任何其他编码位模式的前缀。这允许编码的位流逐个位地读取，并且每当遇到表示字形的一组位时，就可以对该字形进行解码。如果不强制执行无前缀约束，那么这样的解码将是不可能的。
考虑文本“AAAAABCD”。使用 ASCII 编码，这将需要 64 位。如果我们改为用位模式“00”编码“A”，“01”编码“B”，“10”编码“C”，“11”编码“D”，那么我们可以仅用 16 位来编码此文本；得到的位模式将是“0000000000011011”。然而，这仍然是固定长度编码；我们为每个字形使用 2 位而不是 8 位。由于字形“A”出现的频率更高，我们通过用更少的位编码它是否能做得更好？实际上可以，但为了保持无前缀编码，一些其他的位模式将变得长于 2 位。一个最优编码是用“0”编码“A”，“10”编码“B”，“110”编码“C”，“111”编码“D”。（显然这不是唯一的最优编码，因为很明显对于任何给定的编码，B、C 和 D 的编码可以自由互换而不会增加最终编码消息的大小。）使用此编码，该消息仅用 13 位编码为“0000010110111”，压缩比为 4.9 比 1（即，最终编码消息中的每个位代表的信息量与原始编码中的 4.9 位相同）。从左到右读取此位模式，您会看到无前缀编码即使代码具有不同的位长度，也能轻松将其解码为原始文本。
作为第二个示例，考虑文本“THE CAT IN THE HAT”。在这个文本中，字母“T”和空格字符都具有最高的频率，因此在最优编码中它们显然具有最短的编码位模式。然而，字母“C”、“I”和“N”只出现一次，所以它们将具有最长的代码。
有许多可能的无前缀可变长度位模式集可以产生最优编码，即可以使文本以最少的位数进行编码。一种这样的最优编码是用“00”编码空格，“100”编码“A”，“1110”编码“C”，“1111”编码“E”，“110”编码“H”，“1010”编码“I”，“1011”编码“N”和“01”编码“T”。因此，最优编码仅需要 51 位，而使用 8 位 ASCII 编码该消息则需要 144 位，压缩比为 2.8 比 1。
输入：输入文件将包含文本字符串列表，每行一个。文本字符串将仅由大写字母数字字符和下划线（用于代替空格）组成。输入的结束将由仅包含单词“END”作为文本字符串的一行表示。此行不应被处理。
输出：对于输入中的每个文本字符串，输出 8 位 ASCII 编码的位长度、最优无前缀可变长度编码的位长度以及精确到一位小数的压缩比。
Sample Input
AAAAABCD
THE_CAT_IN_THE_HAT
END
Sample Output
64 13 4.9
144 51 2.8
运行代码
#include<iostream>
#include<algorithm>
#include<queue>
#include<map>
#include<iomanip>
#include<vector>
#include<functional>
using namespace std;
typedef long long LL;
const int maxn = 1e5 + 5;
const int MOD = 1e9 + 7;
char s[maxn];
map<char, int>Mp;
int a[maxn];
priority_queue<int, vector<int>, greater<int> >que;
int main()
{
cout.setf(ios::fixed);
while (cin >> (s + 1))
{
if (s[1] == 'E' && s[2] == 'N' && s[3] == 'D')break;
while (!que.empty())que.pop();
Mp.clear();
int N = strlen(s + 1);
for (int i = 1; i <= N; i++)Mp[s[i]]++;
for (auto i : Mp)que.push(i.second);
int ans = 0;
while (que.size() > 1)
{
int t1 = que.top();
que.pop();
int t2 = que.top();
que.pop();
ans += t1 + t2;
que.push(t1 + t2);
}
if (ans == 0)ans = que.top();//只有一堆
cout << N * 8 << " " << ans << " " << setprecision(1) << 1.0 * N * 8 / ans << endl;
}
}
代码思路
- 首先定义了一些常量、数据结构和输入输出的格式设置。
maxn表示可能的最大字符串长度。MOD是一个取模常量。- 定义了一个字符数组
s用于存储输入的字符串，一个mapMp用于统计字符出现的次数，一个优先队列que用于处理出现次数。
- 在
main函数中：- 首先设置了固定的输出格式。
- 进入一个循环，不断读取输入的字符串。
- 当输入的字符串以 "END" 开头时，结束循环。
- 每次输入新字符串时，先清空优先队列和
map。 - 遍历输入的字符串，统计每个字符出现的次数，并将次数存入
map。 - 然后将
map中的次数值放入优先队列中。 - 接下来通过一个循环，每次取出优先队列中最小的两个次数值
t1和t2，将它们相加得到新的次数ans，并将新次数放入优先队列中。这个过程模拟了哈夫曼编码的合并节点操作。 - 最后，根据优先队列的最终状态计算并输出结果。如果优先队列最终只有一个元素（即只有一堆），则直接将该元素作为结果；否则，输出计算得到的合并次数总和
ans，同时计算并输出 ASCII 编码长度与哈夫曼编码长度的比值。
HDU1054——Strategic Game
题目描述
运行代码
#include <iostream>
#include <vector>
#include <cstring>
#define MAXN 1505
using namespace std;
bool vis[MAXN];
int pre[MAXN], n; // 匹配路径
vector<int> map[MAXN];
int find(int cur) {
for (size_t i = 0; i < map[cur].size(); ++i) {
int v = map[cur][i];
if (!vis[v]) {
vis[v] = true;
if (pre[v] == 0 || find(pre[v])) {
pre[v] = cur;
return 1;
}
}
}
return 0;
}
int main() {
while (~scanf_s("%d", &n)) {
for (int i = 0; i < n; ++i) {
map[i].clear();
}
int u, v, m;
for (int i = 0; i < n; ++i) {
scanf_s("%d:(%d)", &u, &m);
while (m--) {
scanf_s("%d", &v);
map[v].push_back(u);
map[u].push_back(v);
}
}
int ans = 0;
memset(pre, 0, sizeof(pre));
for (int i = 0; i < n; ++i) {
memset(vis, false, sizeof(vis));
if (find(i)) {
ans++;
}
}
printf("%d\n", ans / 2);
}
return 0;
}#include <iostream>
#include <vector>
#include <cstring>
#define MAXN 1505
using namespace std;
bool vis[MAXN];
int pre[MAXN], n; // 匹配路径
vector<int> map[MAXN];
int find(int cur) {
for (size_t i = 0; i < map[cur].size(); ++i) {
int v = map[cur][i];
if (!vis[v]) {
vis[v] = true;
if (pre[v] == 0 || find(pre[v])) {
pre[v] = cur;
return 1;
}
}
}
return 0;
}
int main() {
while (~scanf_s("%d", &n)) {
for (int i = 0; i < n; ++i) {
map[i].clear();
}
int u, v, m;
for (int i = 0; i < n; ++i) {
scanf_s("%d:(%d)", &u, &m);
while (m--) {
scanf_s("%d", &v);
map[v].push_back(u);
map[u].push_back(v);
}
}
int ans = 0;
memset(pre, 0, sizeof(pre));
for (int i = 0; i < n; ++i) {
memset(vis, false, sizeof(vis));
if (find(i)) {
ans++;
}
}
printf("%d\n", ans / 2);
}
return 0;
}代码思路
-
定义了一些常量和变量：
MAXN表示可能的最大节点数。vis数组用于标记节点是否已访问。pre数组用于记录匹配路径。n表示节点数量。map是一个向量数组，用于存储每个节点连接的其他节点。
-
find函数：- 这是一个深度优先搜索的函数，用于尝试为当前节点
cur找到匹配。 - 遍历当前节点连接的所有节点
v。 - 如果
v未被访问，将其标记为已访问。 - 如果
v没有预先匹配的节点或者能为pre[v]找到匹配，就将v与当前节点cur匹配，并返回 1 表示找到匹配。 - 如果遍历完都没找到匹配，返回 0 。
- 这是一个深度优先搜索的函数，用于尝试为当前节点
-
main函数：- 不断读取节点数量
n。 - 对于每个节点数量，先清空
map数组。 - 读取每个节点的信息，包括节点编号、连接的边数和连接的节点，并构建
map数组。 - 初始化
pre数组和结果变量ans。 - 对每个节点进行遍历，通过调用
find函数尝试匹配。 - 如果能找到匹配，增加
ans的值。 - 最后输出匹配的结果
ans / 2。
- 不断读取节点数量
HDU1055——Color a Tree
题目描述
Sample Input
5 1
1 2 1 2 4
1 2
1 3
2 4
3 5
0 0
Sample Output
33
运行代码
#include <iostream>
using namespace std;
const int MAX_N = 1010;
int pre[MAX_N];
int nex[MAX_N];
int c[MAX_N];
int num[MAX_N];
int visit[MAX_N];
int sum[MAX_N];
int father[MAX_N];
int n, r;
int findMax() {
double maxVal = 0;
int index = -1;
for (int i = 1; i <= n; i++) {
if (maxVal < (sum[i] * 1.0) / num[i] && visit[i] == 0) {
maxVal = (sum[i] * 1.0) / num[i];
index = i;
}
}
return index;
}
void merge(int x) {
int i;
for (i = father[x]; pre[i] != -1; i = pre[i]);
sum[i] += sum[x];
num[i] += num[x];
for (i = father[x]; nex[i] != -1; i = nex[i]);
nex[i] = x;
pre[x] = i;
visit[x] = 1;
}
int main() {
while (cin >> n >> r && n && r) {
for (int i = 1; i <= n; i++) {
cin >> c[i];
sum[i] = c[i];
visit[i] = 0;
pre[i] = nex[i] = -1;
num[i] = 1;
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
father[b] = a;
}
visit[r] = 1;
while (true) {
int index = findMax();
if (index == -1) break;
merge(index);
}
int ans = 0, count = 1;
for (int i = r; i != -1; i = nex[i]) {
ans += count * c[i];
count++;
}
cout << ans << endl;
}
return 0;
}代码思路
-
首先定义了一些常量和数组：
pre数组用来表示当前集合（包含某个元素）的前一个元素。nex数组表示当前集合的下一个元素。c数组存储每个元素的值。num数组记录当前集合的元素个数。visit数组标记元素是否已处理。sum数组记录当前集合元素的总和。father数组记录每个元素的父元素。
-
findMax函数用于找到当前权值（元素和除以元素个数）最大且未被访问的集合。 -
merge函数用于将一个元素所在的集合合并到其父元素所在的集合中。 -
在
main函数中：- 首先进行输入数据的初始化，包括读取每个元素的值，初始化相关数组。
- 建立元素之间的父子关系。
- 将根节点
r标记为已访问。 - 然后进入一个循环，不断找到权值最大的未处理集合，并进行合并操作。
- 最后计算并输出最终的结果，通过遍历从根节点开始的集合，计算每个元素乘以其位置的累加和。
4068
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
