上海月赛：火柴数字（二）（暴力搜索，DP）

weixin_51184047

已于 2022-08-07 10:52:14 修改

阅读量707

点赞数 1

分类专栏：算法文章标签：算法深度优先动态规划

于 2022-07-14 23:01:09 首次发布

本文链接：https://blog.csdn.net/weixin_51184047/article/details/125794595

版权

算法专栏收录该内容

32 篇文章

订阅专栏

本文介绍了一道关于使用n根火柴表示最大m倍数数字的编程问题，通过暴力搜索和动态规划两种方法进行解决。动态规划策略利用状态转移方程和快速幂技巧，有效地降低了时间复杂度，找到满足条件的最优解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

火柴数字（二）

内存限制: 256 Mb

时间限制: 1000 ms

题目描述

使用火柴表示 0 到9 的方法如下：

在这里插入图片描述

给定两个参数 n 与 m，请用 n 根火柴（不必全部用完），组成一个尽量大的数字，并且它是 m 的倍数。

输入格式

两个正整数：n 与 m。

输出格式

单个自然数：表示满足要求的最大值，由于 00 是任何正整数的倍数，可以保证答案一定存在。

数据范围

对于 50% 的数据， $6\leq n\leq 20$ ；
对于 100% 的数据， $6\leq n\leq 3000;10\leq m\leq 3000$ ；

样例数据

输入:

6 3

输出:

思路一：暴力搜索 50 分

递归回溯就好了。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

int a[10] = {6,2,5,5,4,5,6,3,7,6};
int n, m; // n根火柴，%m ==0。
int cnt=0;
int ans =0;
void dfs(int res, int sum) // 剩余火柴数， 总数。
{
    if(sum%m == 0 && res >=0)
    {
        // printf("%d ",sum);
        ans = max(ans, sum);
        // return;这个地方不能直接返回。 
    }
    if(res == n)
    {
        for (int i = 1; i <= 9; i ++ )
        {
            sum = sum *10 +i;
            res -= a[i];
            dfs(res, sum);
            res+=a[i];
            sum = (sum -i)/10;
            
        }
    } 
    else if (res < n && res>=0)
    {
        for (int i = 0; i <= 9; i ++ )
        {
            sum = sum *10 +i;
            res -= a[i];
            dfs(res, sum);
            res+=a[i];
            sum = (sum -i)/10;
        }
        
    }
    
}

int main()
{
    cin >> n >> m;
    
    dfs(n,0);
    
    cout << ans << endl;
    
}

思路二：动态规划100分

算法思路：
1、该题是《火柴数字(一)》的升级，依然尝试动归，题意要求：用不超过n根火柴拼出一个最大的自然数，使其模m为0。
2、先考虑最大的自然数：位数越长越优，位数一定的情况下从高位至低位，各位上的数越大越优。火柴不超过n根，最长位数显然只可能为n/2（全由数字“1”构成），最短位数为1（即数字0）。
又，该数模m为0：若能先求得符合题意的数最长位数为len且模m为0，再想法构造出这个数就容易了，即只需从高位至低位枚举9~0即可。
3、描述状态： $f [j] [k]$ 表示拼成长为j（位数）模m为k的数所需要的最少火柴根数。
4、状态转移：若 $f [j] [k]$ 已知，考虑在此长为j的数X后加入数字t=9~0（细节：最高位不能为0，特判X为0的情形），则有：

在这里插入图片描述

$f[j+1][(k*10+t)\%m]=min{f[j][k]}+g[t]$
g[t] 表示数字t（9~0）所需的火柴根数。
边界： m>=10， $f [1] [t] = g [t]; t = 0...9; f [0] [0] = 0$ 其余初始化为极大值
求 $f [j] [k]$ 该过程的时间复杂度：O(10n*m)
5、求符合题意的最长位数len：倒着遍历j=n/2~1，满足 $f [j] [0] <= n$ 则退出，即len=j。
6、由 $f [l e n] [0]$ 从高位至低位构造符合题意的数：枚举位数j=len…1，若该数第j位取t=9…0，可拆分为以下两部分：最高位数t+后j-1位的数X

初始k=0，若该位取t满足： $f [j - 1] [kk] + g [t] <= n$ ，其中kk表示X%m（用calc求解），则t为该位最大可能取值，直接输出该位结果，更新k、n。
函数calc(t, j, k)：用于求解等式 $t * 10^{j-1}\%m+kk)\%m=k$ 中的kk。（快速幂）
该过程时间复杂度O(10nlgn)
7、如此，时间复杂度为O(10n*m+10nlgn)，得解。

// 火柴数字https://iai.sh.cn/contribution/2160

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 3005;
const int M = 3005;
/*动态规划+快速幂*/
int n, m, f[N][M], g[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6}; //数字0~9所需火柴棍数
int calc(int t, int j, int k)
{ //快速幂计算kk：(t*10^j+kk)%m=k
    int x, a;
    x = 1, a = 10; // a^j%m
    while (j)
    {
        if (j % 2)
            x = x * a % m;
        a = a * a % m, j >>= 1;
    }
    x = t * x % m;
    return (k + m - x) % m;
}
int main()
{
    // freopen("match.in","r",stdin);
    // freopen("match.out","w",stdout);
    cin >> n >> m; // n根火柴 数字m
    memset(f, 0x7f, sizeof(f));
    f[0][0] = 0;
    for (int k = 0; k < 10; k++)
        f[1][k] = g[k]; //边界
    int len = 1;
    for (int j = 1; j <= n / 2; j++)
    {                               //长为j位
        for (int k = 0; k < m; k++) //模m为k
            for (int t = 9; t >= 0; t--)
            { //最低位取t
                if (j == 1 && k == 0)
                    break;
                int i = (k * 10 + t) % m; //长为j+1模m为i
                f[j + 1][i] = min(f[j + 1][i], f[j][k] + g[t]);
            }
    }
    for (int j = n / 2; j >= 1; j--)
        if (f[j][0] <= n)
        { //满足题意的数的最长位数
            len = j;
            break;
        }
    if (len == 1)
    {
        cout << 0;
        return 0;
    }
    int i, k;
    i = k = 0; //由f[len][0]来构造答案
    for (int j = len; j >= 1; j--)
    { //从高位->低位构造出长为len的最大的自然数
        for (int t = 9; t >= 0; t--)
        { //求出kk：(t*10^(j-1)+kk)%m=k
            int kk = calc(t, j - 1, k);
            if (g[t] + f[j - 1][kk] <= n)
            {                      //该位取t合法
                cout << t;         //逐位输出
                k = kk, n -= g[t]; //计入答案、更新k和剩余火柴数n
                break;
            }
        }
    }
    return 0;
}