计硕二班刘泽政 2022222243 第四章作业

理想何止三旬7 2023-01-02 16:55:04

1. 概括第四章学习内容，总结第四章学习心得。

贪心算法的概念
贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，算法得到的是在某种意义上的局部最优解。

贪心算法的基本要素
（1）贪心选择性质
一个问题的整体最优解可通过一系列局部的最优解的选择得到，并且每次的选择可以依赖以前作出的选择，但不依赖于后面要作出的选择。这就是贪心选择性质。对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所作的贪心选择最终导致问题的整体最优解。
对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每步所做的贪心选择最终导致问题的整体最优解。首先考察问题的一个整体最优解，并证明可修改这个最优解，使其以贪心选择开始。做了贪心选择后，原问题简化为规模更小的类似子问题。然后用数学归纳法证明，通过每一步做贪心选择，最终可得到问题的整体最优解。其中，证明贪心选择后的问题简化为规模更小的类似子问题的关键在于，利用该问题的最优子结构性质。

（2）最优子结构性质
当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。问题的最优子结构性质是该问题可用动态规划算法或贪心算法求解的关键特征。

贪心算法与动态规划算法的差异

贪心策略：在每一步中做选择；在解子问题之前做选择；局部最优即全局最优；自顶向下解决问题

动态规划：在每一步中做选择；选择依赖于子问题的最优解；自底向上解决问题

动态规划算法中，每步所做的选择往往依赖于相关子问题的解。因而只有在解出相关自子问题后，才能做出选择。而在贪心算法中，仅在当前状态下做出最好选择，即局部最优选择。再去解做出这个选择后产生的相应子问题。贪心算法所作的贪心选择可以依赖以往所做过的选择，但决不依赖将来所做的选择，也不依赖子问题的解。
正是由于这种差别，动态规划算法通常以自底向上的方式解决各子问题，贪心算法则通常以自顶向下的方式进行，以迭代的方式做出相继的贪心选择，每做一次贪心选择，就将所求问题简化为规模更小的子问题。

贪心算法设计步骤

（1）将最优化问题转化为如下形式：做出一次选择后，只剩下一个子问题要求解
（2）证明做出贪心选择后，总能求得原问题最优解，即贪心选择安全
（3）证明做出贪心选择后，子问题具有最优子结构性质。

2. 以{0-1}背包问题和背包问题为例，讨论动态规划算法与贪心算法的异同。

贪心算法
基本思想：贪心算法并不从整体最优上加以考虑，它所做的选择只是在某种意义上的局部最优解。
基本要素：最优子结构性质和贪心选择性质。

可从两者的基本要素可以看出，两者的共同点是都有最优子结构。

不同点：
1) 动态规划算法中，每步所做的选择往往依赖于相关子问题的解，因而只有在解出相关子问题时才能做出选择。而贪心算法，仅在当前状态下做出最好选择，即局部最优选择，然后再去解做出这个选择后产生的相应的子问题。

2) 动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常自顶向下的方式进行。

3. 算法实验2：完成教材114页算法实现题4-2，总结实验出现问题及解决方法。

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int n;
int cmp(int a,int b)
{
	return a>b;
}
int better_sort(int a[],int m)
{
	int b[n];
	int sum=0;
	for(int i=0;i<n;i++)
		b[i]=a[i];
	while(m>1)
	{
		sort(b,b+m);
		b[0]=b[0]+b[1];
		sum+=b[0];
		for(int i=1;i<m-1;i++)
			b[i]=b[i+1];
		m--;
	}
	return sum-n+1;
}
int worse_sort(int a[],int m)
{
	int b[n];
	int sum=0;
	for(int i=0;i<n;i++)
		b[i]=a[i];
	while(m>1)
	{
		sort(b,b+m,cmp);
		b[0]=b[0]+b[1];
		sum+=b[0];
		for(int i=1;i<m-1;i++)
			b[i]=b[i+1];
		m--;
	}
	return sum-n+1;
}
int main()
{
	//int a[100];
	cin>>n;
    int a[n+1];
	for(int i=0;i<n;i++)
		cin>>a[i];
	cout<<worse_sort(a,n)<<" "<<better_sort(a,n)<<endl;
	return 0;
 }

由题目已知得合并长度为m和n需要比较次数为m+n-1,要想得到最优合并顺序，根据贪心算法的思想，局部最优即全局最优，先考虑长度最短的两个数进行合并，合并后的数字加入数组中然后再次挑选长度最短的两个数合并，每次合并都让记录次数的值进行加法就可以，一直到将所有数据合并完为止。

首先用一个数组存储要合并的序列，如果要求最优合并，则升序排列，每次合并后的数字替代合并前的第二个数字，然后对后面的再次排序，重复前面的步骤。

如果是最差情况，则降序排列，从最大的开始，每次挑选最大的两个数字合并，合并后的数字加入原数组，再排序然后合并。

5. 算法实验2：完成教材118页算法实现题4-14，总结实验出现问题及解决方法。

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

int main()
{
    int n,k,x;   
    long long sum1=0,sum2=0;  
    priority_queue<int, vector<int>, greater<int> > q1;   
    priority_queue<int, vector<int>, less<int> > q2;   
    cin>>n>>k;
    for(int i=0;i<n;i++)   
    {
        cin>>x;
        q1.push(x);
        q2.push(x);
    }
    while(q1.size()%(k-1)!=1)   
        q1.push(0);  
    while(q1.size()>1)
    {
        long long sum=0;
        for(int i=0;i<k;i++)   
        {
            sum+=q1.top();   
            q1.pop();   
        }
        sum1+=sum;   
        q1.push(sum);  
    }

    while(q2.size()>1)
    {
        long long sum=0;
        for(int i=0;i<2;i++)
        {
             sum+=q2.top();
             q2.pop();
        }
        sum2+=sum;
        q2.push(sum);
    }
    cout<<sum2<<" "<<sum1<<endl;
    return 0;
}

（1）分别创建一个递增的优先队列和一个递减的优先队列。创建队列的优点是可以对数字自动排序、取数等一些操作方便，如q.top();表示取队首元素。
（2）对于递增队列：① 先判断是否需要加“0”堆，需要就加；② 只要队列中的元素个数大于1（等价于队列中还至少有k堆石子，当然剩余石子堆数为k的整数倍），就对队列前k个元素进行处理。每次将队首加入到sum中，加完后就把队首弹出队列，继续处理下一个队首，直至处理了k个队首（即合并了k堆石子）。得到n个sum后，将sum累加起来，得到的就是最小费用。
（3）对于递减队列：方法同二，只是这里是连续处理2个队首。

...全文