第一关：贪心法

任务描述：

相关知识：

贪心法的优缺点：

例题：

解题分析：

程序实现：

关键代码：

编程要求：

测试说明：

第二关：最小生成树

任务描述：

相关知识：

最小生成树概念：

Kruskal算法：

贪心策略：

算法图解：

思路再分析：

编程要求：

测试说明：

第3关：Huffman 编码

任务描述：

相关知识：

最小生成树概念：

题目：

如何构造一棵最优的编程树：

结论：

编程要求：

测试说明：

第4关：单源点最短路径

任务描述：

相关知识：

单源点最短路径：

Dijkstra算法：

图片说明：

具体实现图：

编程要求：

测试说明：

第一关：贪心法

任务描述：

本关任务：完成乘船问题 ;

编程要求：

根据提示，在右侧编辑器补充代码，完成乘船问题。

测试说明：

平台会对你编写的代码进行测试：

测试输入：

6 85
5 84 85 80 84 83

预期输出： 5

测试输入：

10 85
5 84 85 80 84 83 55 77 6 11

预期输出： 7

#include<iostream>
using namespace std;
const int maxn=10000;

void fast_sort(int *a,int begin,int end){
	int l,r,m;
	l=begin,r=end,m=(begin+end)>>1;
	while(l<=r){
		while(a[l]<a[m]) l++;
		while(a[r]>a[m]) r--;
		if(l<=r){
			int t=a[l];
			a[l]=a[r];
			a[r]=t;
			l++;
			r--;
		}
	}
	if(l<end) fast_sort(a,l,end);
	if(begin<r) fast_sort(a,begin,r);
}

int main(){
	int n,c;
	int a[maxn];
    /********** Begin **********/
    cin>>n>>c;
    for(int i=0;i<n;i++){
        cin>>a[i];
    }
    fast_sort(a,0,n-1);
    int p=0,q=n-1,s=0;  // p代表左索引，q代表右索引
    if(a[q]>c) cout<<"no"<<endl;  // 如果最大的体重(最右边索引的人)大于船的最大载重，那么直接输出 no
    else{
        for(int i=0;i<n;i++){  // 遍历所有人
            if(p>q) break;
            if(a[p]+a[q]>c) q--;  // 如果最小体重的人和当前最大的人不能同船，那么当前体重最大的人就要一个人一个船。
            else p++,q--;  // 当前体重最小的人和当前体重最大的人同船
            s++;
        }
        cout<<s<<endl;
    }
    /********** End **********/
	return 0;
}

第二关：最小生成树

任务描述：

本关任务：理解并实现无向图的最小生成树

编程要求：

根据提示，在右侧编辑器 Begin-End 区间补充代码，完成最小生成树问题。

测试说明：

输入数据：第一行。输出两个数。n和m。后面有n行，对应着n条路径，每行三个值。前两个代表两个点，第三个表示两个点的距离。 m代表有m个点。求m个点的最小生成树的路径值。输出数据: 一个数，为最少权值。

平台会对你编写的代码进行测试：

测试输入：

10 6
1 3 1
1 2 6
1 4 5
2 3 5
2 5 3
3 5 6
5 6 6
3 4 5
3 6 4
4 6 2

预期输出： 15

#include<bits/stdc++.h>
using namespace std;

int n,m;//n为节点总数，m为边数
int ans=0;//ans记录最小权值，
int k=0;//k记录已连接的边数 
int fat[200010];//记录根节点 

struct node//结构体储存边 
{
	int from,to,dis;
}edge[200010];

bool cmp(node a,node b)//sort排序 从小到大排列 
{
	return a.dis<b.dis;
}

int father(int x)//找根节点，并查集的查 
{
	if(fat[x]!=x)
	return father(fat[x]);
	else return x;
}

void unionn(int x,int y)//加入集合，并查集的并 
{
	fat[father(y)]=father(x);
}

int main()
{
	cin>>m>>n;
	for(int i=1;i<=m;i++)
	{
		cin>>edge[i].from>>edge[i].to>>edge[i].dis;
	}
	
	for(int i=1;i<=n;i++) //初始化 没加边之前 每个节点的根节点都是自己 
	{
		fat[i]=i;
	}
	
	sort(edge+1,edge+1+m,cmp);  //排序后，从最小的边开始，满足更新节点就加入集合 
	for(int i=1;i<=m;i++)
	{
		if(k==n-1) break;//连接n个点需要n-1条边 
		if(father(edge[i].from)!=father(edge[i].to))//节点是否更新 
		{
			unionn(edge[i].from,edge[i].to);//加入集合 
			ans+=edge[i].dis;//加上权值 
			k++;//边数加1 
		}
	}
	cout<<ans;
	return 0;
}

第3关：Huffman 编码

任务描述：

本关任务：理解并实现Huffman编码树 ;

编程要求：

根据提示，在右侧编辑器 Begin-End 区间补充代码，完成Huffman编码树问题。

测试说明：

平台会对你编写的代码进行测试：

输入数据: 第一行，一个输入(n)，n表示有n行。后面两行，第一个值是字符，第二个值是频率。输出一行，为多少位内存空间。 $内存空间=一个字符串的位编码长度*频率$ 输出数据：最短编码长度

测试输入：

6
a 45
b 13
c 12
d 16
e 9
f 5

预期输出： 224

#include<bits/stdc++.h>
using namespace std;

typedef struct//哈夫曼树的存储表示
{
    char s;
    int weight;    					//权值
    int parent, lChild, rChild;    	//双亲及左右孩子的下标 
}HTNode, *HuffmanTree;

void Select(HuffmanTree hT, int n, int &s1, int &s2)//选择两个最小节点 
{
    s1 = s2 = 0;
    int i;
    for(i = 1; i < n; ++ i)//选择两个未有双亲的节点 
	{
        if(hT[i].parent == 0)
		{
            if(0 == s1)
			{
                s1 = i;
            }
            else
			{
                s2 = i;
                break;//后面一个for循环的标记 
            }
        }
    }
    if(hT[s1].weight > hT[s2].weight)//确保s1>s2 
	{
        int t = s1;
        s1 = s2;
        s2 = t;
    }
    for(i+=1;i<n;++i)//选择s2即break 故从i+1开始选择两个最小节点 
	{
        if(hT[i].parent==0)
		{
            if(hT[i].weight < hT[s1].weight)
			{
                s2 = s1;
                s1 = i;
            }
			else if(hT[i].weight < hT[s2].weight)
			{
                s2 = i;
            }
        }
    }
    //cout<<s1<<" "<<s2<<"**"<<endl;
}

void CreateHufmanTree(HuffmanTree &hT)//构造哈夫曼树 
{
    int n,m;
    cin>>n;
    m = 2*n - 1;
    hT = new HTNode[m + 1];
	hT[0].weight=m;  // 0号节点用来记录节点数量 
    for(int i = 1; i <= m; ++ i)
	{
        hT[i].parent = hT[i].lChild = hT[i].rChild = 0;//初始化 
    }
    for(int i = 1; i <= n; ++ i)
	{
        cin >>hT[i].s>>hT[i].weight;    // 输入权值 
    }
    for(int i = n + 1; i <= m; ++ i)//建立过程 
	{
        int s1, s2;
        Select(hT, i, s1, s2);
        hT[s1].parent = hT[s2].parent = i;
        hT[i].lChild = s1; hT[i].rChild = s2;    			//作为新节点的孩子 
        hT[i].weight = hT[s1].weight + hT[s2].weight;    	//新节点为左右孩子节点权值之和 
    }
    
}

int HuffmanTreeWPL_(HuffmanTree hT, int i, int deepth)//递归计算WPL 
{
    if(hT[i].lChild == 0 && hT[i].rChild == 0)
	{
        return hT[i].weight * deepth;
    }
    else
	{
        return HuffmanTreeWPL_(hT, hT[i].lChild, deepth + 1) + HuffmanTreeWPL_(hT, hT[i].rChild, deepth + 1);
    }
}

int HuffmanTreeWPL(HuffmanTree hT)//计算WPL 
{
    return HuffmanTreeWPL_(hT, hT[0].weight, 0);
}

void DestoryHuffmanTree(HuffmanTree &hT)//销毁哈夫曼树 
{
    delete[] hT;
    hT = NULL;
}

int main()
{
    HuffmanTree hT;
    CreateHufmanTree(hT);
    cout << HuffmanTreeWPL(hT) << endl;
    DestoryHuffmanTree(hT);
    return 0;
}

第4关：单源点最短路径

任务描述：

本关任务：理解并实现单源点最短路径

编程要求：

根据提示，在右侧编辑器补充代码，完成单源点最短路径问题。

测试说明：

平台会对你编写的代码进行测试：

输入数据：第一行，一个输入(n)，n表示有n条边。后面n行，每行三个值，前两个是顶得，第三个是距离。输出n行，顶得到所有结点的距离。输出数据: 起点到任意点的最短路径的距离。

测试输入：

7
v1 v2 10
v2 v3 50
v3 v4 20
v3 v5 10
v4 v5 60
v1 v5 100
v1 v4 30

预期输出：

v1 0
v2 10
v4 30
v3 50
v5 60

#include<iostream>
using namespace std;
/********** Begin **********/
#define N 100
#define Min(a,b) a>b?b:a
#define INF 1000
int dis[N], bj[N];
int mp[N][N];
int n;
void djsk(int v, char** names)
{
    int i, j, k, min;
    for (i = 0; i < n; i++)
        dis[i] = mp[v][i];//初始化dis数组,代表从起始点到i点的最短距离 
    dis[v] = 0;// v  代表起始节点 自己到自己为0 
    bj[v] = 1;// 标记 已找到短路 
    cout << names[0] << "   " << dis[0] << endl;
    for (i = 0; i < n; i++)// i 代表已经找到的最短路条数 
    {
        min = INF; k = 0;
        for (j = 0; j < n; j++)//从未找到最短路径元素中找一个路径最短的 
            if (!bj[j] && dis[j] < min) { min = dis[j], k = j; }
        if (k != 0)
            cout << names[k] << "   " << dis[k] << endl;
        bj[k] = 1;// 标记 已找到短路 
        for (j = 0; j < n; j++)//用但前最短路节点更新未找到最短路的节点 
            if (dis[j] > (dis[k] + mp[k][j]))dis[j] = dis[k] + mp[k][j];
    }
}
/********** End **********/

int main(){
	/********** Begin **********/
        cin >> n;
    char** names = new char* [5];
    char from[3], to[3];
    int len;
    for (int i = 0; i < 5; i++) {
        names[i] = new char[5];
        names[i][0] = 'v';
        names[i][1] = (i + 1) + '0';
        names[i][2] = 0;
        dis[i] = INF;
        for (int j = 0; j < 5; j++) {
            mp[i][j] = INF;
        }
    }
    fflush(stdin);
    for (int i = 0; i < n; i++) {
        cin >> from;
        cin >> to;
        cin >> len;

        mp[from[1] - '0' - 1][to[1] - '0' - 1] = len;
        mp[to[1] - '0' - 1][from[1] - '0' - 1] = len;
    }
    n = 5;
    djsk(0, names);
    for (int i = 0; i < 5; i++) {
        delete[] names[i];
    }
    delete[] names;
	/********** End **********/
	return 0;
}