算法学习之每日一题Day3

题目   带分数

一、有关题目（涉及算法：递归，搜索，剪枝）

1.题目来源：第四届蓝桥杯省赛C++B/C组,第四届蓝桥杯省赛JavaA/B组

                     AcWing 1209

2.题目链接：https://www.acwing.com/problem/content/1211/

3.题目描述

100 可以表示为带分数的形式：100=3+69258714

还可以表示为：100=82+3546197

注意特征：带分数中，数字 1∼9分别出现且只出现一次（不包含 0）。

类似这样的带分数，100有 11种表示法。

输入格式

一个正整数。

输出格式

输出输入数字用数码 1∼9

不重复不遗漏地组成带分数表示的全部种数。

数据范围

1≤N<106

输入样例1：

100

输出样例1：

11

输入样例2：

105

输出样例2：

6

时/空限制： 1s / 64MB

 二、抽象模型

可以将题目要求抽象为下面的数学公式

n = a + b/c

a, b, c 是满足上述题目的要求（数字 1∼9分别出现且只出现一次（不包含 0））的非0整数。

这样便可抽象出此题主体应该是考查排列型枚举，可利用递归算法求解。

三、算法思路

利用递归求解排列型枚举的时间复杂度为O(n * n!)，其中n指的是枚举的数字范围，在本题中是1~9。（易错注意：本题的时间范围和题目中的N没有关系，不要被迷惑）

思路1：暴力解法

具体思路

1.全排列1~9。【O（n*n!)】

相关基础题目：

经过第一步后并不能明确a,b,c具体的数值

2.从全排列的结果中用两重循环暴力分解出三段，形如下图，通过 i,j 将一个排列分割，每段代表一个数（本质是一个隔板问题）

复杂度

3.判断是否符合题目要求

要求（1）：满足等式n = a + b/c;

要求（2）：a,b,c是符合题目要求的整数。

易错注意：由于题目涉及除法，而c++中的“/”是整除，因此，应将等式两边乘分母c，或者将b强制类型转换为double。

思路合理性分析

对应代码量较小的程序，这个复杂度大多不会超时。

思路2：思路1的优化

1.充分利用n。

对于等式问题，等式两边的数值都可以充分利用。

将等式变形为

c*n = c*a + b

这样只需要枚举a,c，最后利用等式算出b，再对其合理性进行判断即可。

2.将思路1的1，2，3合并。（均可利用递归搜索树解决）

先dfs a，在 a 的每一个叶子节点的地方（因为每一个叶子就代表每一个 a 的可能成立的方案），我们都需要再枚举一下 c，即dfs c。
也就是我们要把 a 的每一个节点扩展成一个搜索树（即在 a的每一个叶节点的时候dfs一下 c），叶子上的每一棵树都是对 c 的搜索，因此这里其实是dfs的嵌套关系，（即在一个dfs的过程中，把它的叶节点再dfs一下） 所以我们需要在dfs搜索 a 的时候在 a 的叶节点的基础上搜索一下对应的 c 是多少。

3.加入多个剪枝语句。

在dfs中，剪枝语句的使用，可以大大减少算法的时间复杂度。

思路1的写法，由于dfs只出现在步骤1（枚举阶段），此时能利用的题目限制条件较少，因此能加入的剪枝语句也较少。

思路2的写法，将dfs贯穿于整个求解过程，此时可以将题目限制条件全部用于剪枝。

易错注意：当利用b = n*c - a*c计算b时，当n和c数值较大时，会导致int溢出，从而导致程序出错。

解决方法1：将b的数据类型改为long long。（由于在计算n*c时就可能导致int溢出，而c和n的数据类型均为int，因此可以作如下处理）

long long b = n - a;
b *= c;

解决方法2：将N开的大一些。

之所以，int溢出后会导致答案出错，是因为，int溢出后b就可能变成负数，从而它的个位数字的余数也可能是负数，那么backup[x]的下标就可能是负数，所以下标就越界了。

原则：写算法题一般数组建议开大一些，只要在空间限制内就可以。（毕竟是算法题只要能过就行，所以为了安全起见就开大一些~）

四、相关代码

1、思路1代码

#include<iostream>
#include<cstring>
#include<cstdio>

using namespace std;

const int N = 15;

int n;

int ans[N];
int visited[N];
int t, p, q;

void check(int a, int b, int c){ // 求得a,b,c；判断。
    for(int i = 1; i <= p; ++ i){
        a = 10*a + ans[i];
    }
    
    for(int i = p+1; i <= q; ++ i){
        b = 10*b + ans[i];
    }
    
    for(int i = q+1; i <= 9; ++ i){
        c = 10*c + ans[i];
    }
    
    if(c*a + b == c*n) ++ t;
    
}

void Divid(){ // 分解全排列
    for(int i = 1; i < 8; ++ i){
        p = i;
        for(int j = i+1; j < 9; ++ j){
            q = j;
            check(0, 0, 0);
        }
    }
}

void go(int step){ // 求解全排列
    if(step > 9){
      Divid();
      return;    
    }
    
    for(int i = 1; i <= 9; ++ i){
        if(!visited[i]){
            ans[step] = i;
            visited[i] = 1;
            go(step+1);
            ans[step] = 0;
            visited[i] = 0;
        }
    }
}

int main(){
    scanf("%d", &n);
    go(1);
    printf("%d", t);
    return 0;
}

2、思路2代码

#include<iostream>
#include<cstdio>
#include<cstring>
 
using namespace std;
 
int n;
 
const int N = 15;
 
int visited[N], backup[N];
 
int ans;
 
bool check(int a, int c){
    long long b = n - a;  // 易错
    b *= c;
    
    if(!a || !b || !c) return false;
    
    memcpy(backup, visited, sizeof visited);
    
    while(b){
        int x = b%10;
        if(!x || backup[x]) return false;
        backup[x] = 1;
        b /= 10;
    }
    
    for(int i = 1; i <= 9; ++ i){
        if(!backup[i]) return false;
    }
    
    return true;
}
 
void dfs_c(int step, int a, int c){
    if(step > 9) return;
    
    if(c && check(a, c)) ++ ans;
    
    for(int i = 1; i <= 9; ++ i){
        if(!visited[i]){
           visited[i] = 1;
           dfs_c(step+1, a, c*10+i);
           visited[i] = 0;
        }
    }
}
 
void dfs_a(int step, int a){
    if(a >= n) return; // 剪枝
    
    if(a) dfs_c(step, a, 0); 
    
    for(int i = 1; i <= 9; ++ i){
        if(!visited[i]){
           visited[i] = 1;
           dfs_a(step+1, a*10+i);
           visited[i] = 0;
        }
    }
}
 
int main(){
    scanf("%d", &n);
    dfs_a(1, 0);
    printf("%d", ans);
    return 0;
}

五、总结

本题是对递归算法的拓展考查。

其中思路二利用了递归搜索树的嵌套。

本题需要注意的细节点有很多，其中两个易错点尤其需要注意。这两个易错点也是大多有关数学表达式的数值求解问题中的常见易错点。要留意，并记住相应解决方案。