HNU-算法设计与分析-实验2

算法设计与分析
实验2

计科210X 甘晴void 202108010XXX

目录

1 用动态规划法实现0-1背包

问题重述

一共有N件物品，第i（i从0开始）件物品的重量为weight[i]，价值为value[i]。在总重量不超过背包承载上限maxw的情况下，求能够装入背包的最大价值是多少

想法

经典问题，假设我们现在手上有一个空的背包，然后从0个物品开始按照序号从小到大拿可供选择的物品，对于每个物品我们只有“选择”或者“不选择”两种策略。

状态dp[i][j]表示选择到第i个物品后，背包容量为j时所拿所有物品的最大价值。对于每一个物品而言，我们只有“拿”与“不拿”这两种处置方法。首先看看在当前状态下，如果腾空背包，能不能拿下它，如果即使背包空了都没法拿下它，那只能选择“不拿”，继承拿到前一个物品时这个大小的背包的状态；如果可能拿下它，那么我们可以选择“不拿”，跟前面一样处理，或者“拿”，这就要求腾出这个空间，但加上这个价格。

最优子结构易证：

假设（y1,y2,y3,……,yn）为所给01背包问题的一个最优解，则照理（y2,y3,……,yn）应该是其子问题的最优解。我们假设（y2,y3,……,yn）并不是其最优解，另存在（z2,z3,……,zn）为其子问题的最优解，那么一定有（y1,z2,z3,……,zn）为该问题的最优解，而非（y1,y2,y3,……,yn）是该问题的最优解，这与我们一开始的假设矛盾，故这是不成立的。所以该问题一定有最优子结构。

重叠子问题：

显然在计算i和j较大时的dp[i][j]必然会用到较小的dp[i][j]的值，故有重叠子问题。

这样，我们有状态转移方程如下：

dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

有了状态转移方程就可以写代码了。

代码

#include 
using namespace std;

int max(int a, int b)
{
    return a > b ? a : b;
}

int solve(int n, int maxw, int weight[], int value[])
{
    // weight[]重量
    // value[]价值
    int dp[n][maxw + 1];
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < maxw + 1; j++)
        {
            dp[i][j] = 0;
        }
    }
    for (int k = 0; k < maxw + 1; k++)
    {
        if (weight[0] <= k)
            dp[0][k] = value[0];
    }
    for (int i = 1; i < n; i++)
    {
        for (int j = 0; j < maxw + 1; j++)
        {
            if (j - weight[i] < 0)
                dp[i][j] = dp[i - 1][j];
            else
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
        }
    }
    return dp[n - 1][maxw];
}

int main()
{
    int n, maxw;
    scanf("%d %d", &maxw, &n);
    int w[n], v[n];
    for (int i = 0; i < n; i++)
    {
        scanf("%d %d", &w[i], &v[i]);
    }
    printf("%d\n", solve(n, maxw, w, v));
}

验证

洛谷P1048 [NOIP2005 普及组] 采药（https://www.luogu.com.cn/problem/P1048）与这道题较为类似。

基本上是一模一样的，我们可以测试一下，结果如下：

可见算法正确。

算法分析

时间复杂度O(nm)，n为物品个数，m为最大背包容量。

空间复杂度O(nm)，开了个这个数组。

2 用贪心算法求解背包问题

问题重述

有n个物品，每个物品的重量weight[i]和价格value[i]，物品可以被分割，背包容量maxw，求最多拿走价值为多少。

想法

贪心背包和01背包，区别就在于“可以分割”，那么贪心策略就变为了优先取走“性价比”较高的物品，并按照这样的策略尽可能多的取走物品，如果能取走就尽可能取走，最后一个物品如果取不走，就分割取走可以取走的部分。

代码

#include 
#include 
using namespace std;

struct object
{
    int weight;
    int value;
    double vpw; // value per weight
};

bool cmp(struct object a, struct object b)
{
    return a.vpw > b.vpw;
}

double solve_greedy(int n, int maxw, int weight[], int value[])
{
    // weight[]重量
    // value[]价值
    struct object x[n];
    for (int i = 0; i < n; i++)
    {
        x[i].weight = weight[i];
        x[i].value = value[i];
        x[i].vpw = (double)x[i].value / x[i].weight;
    }
    sort(x, x + n, cmp);

    int total = 0;  // 已放入背包的重量
    double ans = 0; // 放入背包的价值
    for (int i = 0; i < n; i++)
    {
        if (total + x[i].weight <= maxw)
        {
            ans += x[i].value;
            total += x[i].weight;
        }
        else
        {
            ans += (((double)(maxw - total) / x[i].weight) * x[i].value);
            break;
        }
    }
    return ans;
}

int main()
{
    int n, maxw;
    scanf("%d %d", &n, &maxw);
    int w[n], v[n];
    for (int i = 0; i < n; i++)
    {
        scanf("%d %d", &w[i], &v[i]);
    }
    printf("%.2lf\n", solve_greedy(n, maxw, w, v));
}

验证

洛谷 P2240 【深基12.例1】部分背包问题（https://www.luogu.com.cn/problem/P2240）就是这个问题

测试，结果如下。

通过了测试点。

算法分析

主要瓶颈在于排序，调用sort函数，按快速排序计，时间复杂度O(nlogn)。

空间复杂度考虑开了个数组，和结构体数组，是一维的，O(n)。

3 半数集问题（实现题2-3）

问题重述

给定一个自然数 n，由 n 开始可以依次产生半数集 set(n)中的数如下。

• (1) n∈set(n)；

• (2) 在 n 的左边加上一个自然数，但该自然数不能超过最近添加的数的一半；

• (3) 按此规则进行处理，直到不能再添加自然数为止。

例如，set(6)={6,16,26,126,36,136}。半数集 set(6)中有 6 个元素。
注意半数集是多重集。

编程任务：

• 对于给定的自然数 n，编程计算半数集 set(n)中的元素个数。

数据输入：

• 输入数据由文件名为 input.txt 的文本文件提供。
• 每个文件只有 1 行，给出整数 n。(0

结果输出:

• 程序运行结束时，将计算结果输出到文件 output.txt 中。输出文件只有 1 行，给出半数集 set(n)中的元素个数。

想法

问题有些复杂的时候可以先举例子。

例如.set(6) 6，16，26，126，36，136。半数集set(6)中有6个元素。

例如.set(10) 10，510，2510，12510，1510，410，2410，12410，1410，310，1310，210，1210，110，半数集set(10)中有14个元素。

设set(n)中的元素个数为f(n)。如：6的前面可以加上1、2、3，而2、3的前面又都可以加上1，也就是f(6)=1+f(3)+f(2)+f(1)。

则显然有递归表达式：f(n)=1+∑f(i)，i=1,2……n/2。

可以先写一个递归函数如下

int f(int n)
{
int temp=1;
if(n>1)
for (int  i=1；i < = n/2；i ++)
       	   temp+=f(i)；
return temp；
}

时间复杂度：n/2个相加，每一个需要计算1+…+i/2，因此时间复杂度为O(n^2)缺点：这样会有很多的重复子问题计算。

这个问题显然存在重叠子问题：例如，当n=4时，f(4)=1+f(1)+f(2)，而f(2)=1+f(1)，在计算f(2)的时候又要重复计算一次f(1)。如果这样的话时间复杂度会很大，我们要想办法简化重叠部分的计算。

可以采用“备忘录”的方法，来避免重叠部分的计算。

代码

#include 
#include 
using namespace std;

int solve(int f[], int n)
{
    if (n == 1)
        return 1;
    if (f[n] != 0)
        return f[n];
    int sum = 1;
    for (int i = 1; i <= n / 2; i++)
        sum += solve(f, i);
    f[n] = sum;
    return sum;
}

int main()
{
    int n;
    scanf("%d", &n);
    int f[n + 1];
    for (int i = 1; i <= n; i++)
        f[i] = 0;
    printf("%d\n", solve(f, n));
}

验证

P1028 [NOIP2001 普及组] 数的计算（https://www.luogu.com.cn/problem/P1028）

测试结果如下：

算法分析

使用到记忆化剪枝，本质上仍然是对每个f[i]都去遍历了f[0]到f[n/2]，所以时间复杂度应该是O(n^2)。

由于开了备忘录数组，空间复杂度O(n)。

3.5 关于此题的进一步探索（半数单集问题，实现题2-4）

为什么会产生重复

2-3和2-4的唯一区别就在这个地方。2-4需要剔除重复的部分。

先来看看重复的部分是怎么产生的：

考虑n=26时的set(n)因为n/2=13，所以13 26∈set(n)但是我们想，1326真的只能这样产生嘛？

考虑26->3 26->1 3 26，也就是说26直接产生3再产生1，这是不是也可以。

这就造成了重复：[1][3][26] 和 [13][26] 都会产生 1326

现在我们要解决这个问题

如何消除重复

如果这道题仍然对n限定很高，那么是不好做的。

但是这里题目限定(0

我们再看刚刚的例子1326，如果是1226还会发生这样的事情嘛？如果是1126呢？

其实我们很好理解为什么【x/10 <= (x%10) /2】会出现重复的情况

因为这会导致(x%10)这一项仍然有能力分出它前面的那个

也就是1326的3，依旧具备产生1的能力，

而1126的右边的1，已经不具备再产生左边的1的能力了。

所以也就是说只有【x/10 <= (x%10) /2】这个情况会出现额外计数的分支，

那我们只需要再这个情况发生的时候，去剪掉由这个产生的分支就可以。

体现在算法上就是在算这一层的答案的时候减掉f[i/10]就好(当i/10*2<=i%10的时候)

代码

#include 
#include 
using namespace std;

int solve(int f[], int n)
{
    if (n == 1)
        return 1;
    if (f[n] != 0)
        return f[n];
    int sum = 1;
    for (int i = 1; i <= n / 2; i++)
    {
        sum += solve(f, i);
        if ((i > 10) && (2 * (i / 10) <= (i % 10)))
        {
            sum -= f[i / 10];
        }
    }
    f[n] = sum;
    return sum;
}

int main()
{
    int n;
    scanf("%d", &n);
    int f[n + 1];
    for (int i = 1; i <= n; i++)
        f[i] = 0;
    f[1] = 1;
    printf("%d\n", solve(f, n));
}

验证

可以看到，对于我们刚刚给出的例子，[13][26]和[12][26]被删去了，效果实现了。

算法分析

由于本题只是进行了一句判断并剪枝，故与上一题一样

使用到记忆化剪枝，本质上仍然是对每个f[i]都去遍历了f[0]到f[n/2]，所以时间复杂度应该是O(n^2)。

由于开了备忘录数组，空间复杂度O(n)。

4 集合划分问题（实现题2-7）

问题重述

n 个元素的集合{1,2,……, n }可以划分为若干个非空子集。例如，当 n=4 时，集合{1，2，3，4}可以划分为 15 个不同的非空子集如下：

{{1}，{2}，{3}，{4}}，
{{1，2}，{3}，{4}}，
{{1，3}，{2}，{4}}，
{{1，4}，{2}，{3}}，
{{2，3}，{1}，{4}}，
{{2，4}，{1}，{3}}，
{{3，4}，{1}，{2}}，
{{1，2}，{3，4}}，
{{1，3}，{2，4}}，
{{1，4}，{2，3}}，
{{1，2，3}，{4}}，
{{1，2，4}，{3}}，
{{1，3，4}，{2}}，
{{2，3，4}，{1}}，
{{1，2，3，4}}

编程任务：
给定正整数 n，计算出 n 个元素的集合{1,2,……, n }可以划分为多少个不同的非空子集。

数据输入：
由文件 input.txt 提供输入数据。文件的第 1 行是元素个数 n。

结果输出:
程序运行结束时，将计算出的不同的非空子集数输出到文件 output.txt 中。

验证方式

本题的验证由在线评测进行

洛谷P5748 集合划分计数（https://www.luogu.com.cn/problem/P5748）

注意与课本题面区别：

• 由于数据很大，题目要求取模
• 有多组数据

★基础知识补充

【贝尔数】

B[n]的含义是基数为 n的集合划分成非空集合的划分数。

贝尔数自身递推关系： B[n+1] = ∑ C(n,k) B[k] ，其中k从0到n。

其中定义B[0] = 1

【第二类斯特林数】

第二类斯特林数实际上是集合的一个拆分，表示将 n个不同的元素拆分成m个集合间有序（可以理解为集合上有编号且集合不能为空）的方案数，记为 S(n,m) （这里是大写的）或者 {n m} (n在上m在下) 。

和第一类斯特林数不同的是，这里的集合内部是不考虑次序的，而圆排列圆的内部是有序的。常常用于解决组合数学中的几类放球模型。描述为：将n个不同的球放入m个无差别的盒子中，要求盒子非空，有几种方案。

S(n,k)的值可以递归的表示为：S(n+1, k) = kS(n, k) + S(n, k-1)。

递推边界条件：

S(n,n) = 1, n>=0

S(n,0) = 0, n>=1

为什么会这样表示呢？当我们将第（n + 1）个元素添加到k个划分集合时，有两种可能性。

• 第n + 1个元素作为一个单独的集合参与到划分成k个集合，有S(n,k-1)个。
• 将第n + 1个元素添加到已经划分的k个集合中，一共有k*S(n,k)种。

【贝尔数与第二类斯特林数的关系】

B[n]=∑S(n,k) 其中k从0到n

参考资料：

【详细讲解第一二三类斯特林数】https://zhuanlan.zhihu.com/p/350774728

【详细讲解贝尔数和贝尔三角形】https://www.cnblogs.com/lfri/p/11549652.html

想法

这是一道数论模板题，相关的知识是【贝尔数】，本题只要根据给定的n求出贝尔数B[n]即可。

结合我们上面给出的基础知识，这里至少有以下几种求贝尔数的方法：

• 算法1：利用贝尔数自身递推关系，循环计算贝尔数
• 算法2：利用贝尔数与第二类斯特林数的关系，k从0到n计算S(n,k)并且累加求和。
• 算法3：使用贝尔三角形（后面讲）

下面逐个分析这些想法：

算法1（贝尔数自身递推）：

想法

主要需要解决的是组合数的计算，数据量较小的时候可以用杨辉三角来计算组合数，数据量较大的时候可能会超时。

可以使用动态规划来计算组合数。

// 计算组合数的代码
#include 
#include
#define ll long long
const int N = 55;
using namespace std;

ll ans[N][N];

void Combinations()  //处理组合数
{
    ans[0][0]=1;
    for(int i=1;i<=40;i++)
    {
        ans[i][0]=1;
        for(int j=1;j<=i;j++)
        {
            ans[i][j]=ans[i-1][j]+ans[i-1][j-1];
        }
    }
}

int main()
{
    ll t;
    cin>>t;
    Combinations();  //记忆化搜索
    ll a,b;
    cin>>a>>b;
    cout<

解决了组合数的计算之后，就可以再利用递推关系，把贝尔数求出来。用到如下关系：

• 贝尔数自身递推关系： B[n+1] = ∑ C(n,k) B[k] ，其中k从0到n。

• 其中定义B[0] = 1

代码

#include 
#define ll long long
const int N = 1000;
const int mod = 998244353;
using namespace std;

ll C[N][N];
ll B[N];

void Combinations() // 处理组合数
{
    C[0][0] = 1;
    for (int i = 1; i <= N - 1; i++)
    {
        C[i][0] = 1;
        for (int j = 1; j <= i; j++)
        {
            C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
        }
    }
}

long long Bell(int n)
{
    if (n == 0)
        return 1;
    ll ans = 0;
    for (int k = 0; k <= n - 1; k++)
    {
        if (B[k] == 0)
            B[k] = Bell(k);
        ans += (C[n - 1][k] * B[k] % mod);
    }
    return ans % mod;
}
int main()
{
    Combinations(); // 记忆化搜索求所有C(n,m)
    for (int i = 0; i < N; i++)
        B[i] = 0;
    B[0] = 1;

    int n, T;
    scanf("%d", &T);
    for (int i = 0; i < T; i++)
    {
        scanf("%d", &n);
        printf("ans = %lld\n", Bell(n));
    }
    return 0;
}

验证

案例数据是可以过的。

但是无法通过在线评测，这是因为我们要求的空间太大了。

但是数据确实要求到了这么大，如果我们开小数据，会出现运行时错误（要求的位置越界了）

说明这种O(n^2)的方法无法通过。

算法分析

时间复杂度O(n^2)

空间复杂度O(n^2)，但是递归消耗的栈空间实在太大了。

不可接受。

（时间足够多，空间足够大的时候可以考虑）

算法2（第二类斯特林数加和）：

想法

主要的问题在于使用递推关系求出第二类斯特林数，再把第二类斯特林数加和得到贝尔数。

// 计算第二类斯特林数
typedef long long ll;
typedef int itn;
const int N = 5007, mod = 1e9 + 7;
int n, m, k;
int S[N][N];
int main()
{
    scanf("%d%d", &n, &k);
    S[0][0] = 1;
    S[n][0] = 0;
    for(int i = 1; i <= n; ++ i) {
        for(int j = 1; j <= k; ++ j) {
            S[i][j] = (S[i- 1][j - 1] + 1ll * j * S[i - 1][j]) % mod;//公式中的 k 是当前的 k
        }
    }
    cout << S[n][k] << endl;
    return 0;
}

计算出第二类斯特林数之后，通过这个关系：

• B[n]=∑S(n,k) 其中k从0到n

求解出B[n]

代码

#include 
#include 
using namespace std;
typedef long long ll;
typedef int itn;
const int N = 5000;
const int mod = 998244353;
int n, m, k;
ll S[N][N];
ll B[N];

int solve_S(int n, int k)
{
    S[0][0] = 1;
    S[n][0] = 0;
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 1; j <= k; ++j)
        {
            S[i][j] = (S[i - 1][j - 1] + 1ll * j * S[i - 1][j]) % mod; // 公式中的 k 是当前的 k
        }
    }
    return 0;
}

ll Bell(int n)
{
    if (n == 0)
        return 1;
    ll ans = 0;
    for (int k = 0; k <= n; k++)
    {
        if (!S[n][k])
            solve_S(n, k);
        ans += S[n][k];
        ans = ans % mod;
    }
    return ans;
}
int main()
{
    for (int i = 0; i < N; i++)
        B[i] = 0;
    B[0] = 1;

    int n, T;
    scanf("%d", &T);
    for (int i = 0; i < T; i++)
    {
        scanf("%d", &n);
        // printf("ans = %lld\n", Bell(n));
        printf("%lld\n", Bell(n));
    }
    return 0;
}

验证

验证可得，案例同样可以过，空间不会超，但是还是TLE。

时间消耗太久了，不可接受。

算法分析

时间复杂度O(n^3)

空间复杂度O(n^2)

算法3（贝尔三角形）：

想法

为什么贝尔三角形可以解决这个计算问题：

代码

#include 
using namespace std;

const int maxn = 100001;
const int mod = 998244353;
long long int bell[maxn], T[maxn];

void Bell(int n, int mod) // 求前n项Bell数
{
    bell[0] = bell[1] = 1;
    T[0] = 1;
    T[1] = 2;
    for (int i = 2; i <= n; i++)
    {
        T[i - 1] = bell[i - 1];
        for (int j = i - 2; j >= 0; j--) // 滚动数组
            T[j] = (T[j] + T[j + 1]) % mod;
        bell[i] = T[0];
    }
}

int main()
{
    int n, t;
    scanf("%d", &t);
    Bell(maxn, mod);
    for (int i = 0; i < t; i++)
    {
        scanf("%d", &n);
        printf("%lld\n", bell[n]);
    }
    // for (int i = 0; i < 100; i++) printf("%d%c", bell[i], (i + 1) % 13 == 0 ? '\n' : ' ');
}

验证

较小的数据是可以通过的，

但是对于较大的数据，仍然未通过评测，显示TLE，O(n^2)的时间复杂度应该是没法通过评测的。

算法分析

时间复杂度应该是O(n^2)

空间复杂度O(n^2)

继续深入

对于一道按点得分的题而言，它的数据点是所有数据点。

洛谷的题解涉及到了FFT（快速傅里叶变换），将时间复杂度降到O(nlogn)之后，就可以通过。但是对于有限的课程实验时间，再结合自身能力而言，我决定暂时做到这里了。这是一个遗憾，后续如果有时间我会继续研究。

实验感悟

对于有一些数论的知识，没有能够掌握，这是一个遗憾。如果有足够的时间，还是要多理解多掌握一些。