基本算法(C++)递推与递归

1、递归实现指数型枚举

题目：从 1~n 这 n 个整数中随机选取任意多个，输出所有可能的选择方案。

输入格式
输入一个整数n。

输出格式
每行输出一种方案

同一行内的数必须升序排列，相邻两个数用恰好1个空格隔开。
对于没有选任何数的方案，输出空行。
本题有自定义校验器（SPJ），各行（不同方案）之间的顺序任意。

数据范围 1≤n≤15

输入样例：
3
输出样例：
3
2
2 3
1
1 3
1 2
1 2 3

思路：

状态压缩递归
状态压缩的特性：可以枚举所有选与不选的情况

题目要求的结果是2^n个
这2^n个选择情况，对应于一个n位的2进制数的各个位取0或取1的情况。

递归树从小到大依次遍历每一位数字，从1-2-3,每一位有选与不选两种情况，选择则表示为该位数，不选为0;
当强状态state用一个二进制数表示选了哪些数，
其中 state |= 1 << (i ) 代表状态的改变，选了i这个数，state >> i & 1则判断第i位有没有被选

例中n=3，即
000 -> \n
003 -> 3
020 -> 2
023 -> 2 3
100 -> 1
103 -> 1 3
120 -> 1 2
123 -> 1 2 3

c++代码：

#include

using namespace std;

int n;

void dfs(int u,int state){
     //u表示枚举第几位数，state表示当前枚举的方案
    if(u==n){
     //当枚举到最后一位数字时
        for(int i=0;i<n;i++){
     //遍历每一位数，把答案打印出来
            if(state>>i&1)
                cout<<i+1<<" ";//第0位打印为1
        }
        cout<<endl;
        return;
    }
    //每一位有两种选择，选与不选
    dfs(u+1,state);//第i位不用这个数
    dfs(u+1,state|(1<<u));//把第u位 置为1
}

int main(){
     
    cin>>n;
    dfs(0,0);
    return 0;
}

2、递归实现组合型枚举

题目：从 1~n 这 n 个整数中随机选出 m 个，输出所有可能的选择方案。

输入格式
两个整数 n,m ,在同一行用空格隔开。

输出格式
按照从小到大的顺序输出所有方案，每行1个。

首先，同一行内的数升序排列，相邻两个数用一个空格隔开。

其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面（例如1 3 5 7排在1 3 6 8前面）。

数据范围 n>0 , 0≤m≤n , n+(n−m)≤25
输入样例：
5 3
输出样例：
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5

思路：

1.通过上一道题目，我们知道这道题目利用了回溯的性质，也就是深度优先搜索
2.相比上一道题，本题应该注意的是，我们只需要选择m个数，并不是所有的数
3.回溯直接可以忽略不记，代码中有体现

代码：

#include
#include
#include

using namespace std;

int n,m;

void dfs(int u,int s, int state){
     
    if(s+n-u<m)return ;//如过把后n-u位都选上仍不能达到m位则当前方案有误
    if(s==m){
     //当前状态已经选了m位，则输出选择情况
        for(int i=0;i<n;i++)
            if(state>>i&1)
                cout<<i+1<<" ";
        cout<<endl;
        return ;
    }
    
    if(u==n)return;//如果以及枚举到第n位了，还是没有找到方案，则表示当前方案不合法
    
    dfs(u+1,s+1,state|(1<<u));//由于题目要求不同行之间也要从小到大排序，因此需要先对该位进行选择
    dfs(u+1,s,state);
    
}

int main(){
     
    cin>>n>>m;
    dfs(0,0,0);
    return 0;
}

3、递归实现排列型枚举

题目：把 1-n这 n 个整数排成一行后随机打乱顺序，输出所有可能的次序。

输入格式
一个整数n

输出格式
按照从小到大的顺序输出所有方案，每行1个。

首先，同一行相邻两个数用一个空格隔开。

其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面。

数据范围 1≤n≤91≤n≤9
输入样例：

3
输出样例：
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

思路：递归求解

排列问题与前两个组合问题不同，组合问题是枚举1-n不同位的两种选择与不选择的情况。
而排列问题枚举的是不同的坑，即每个坑可以使用1-n不同数字，但是已经使用过的数字不可以重复选择。

代码：

#include
#include
#include
#include

using namespace std;

int n;
vector<int> path;


void dfs(int u,int state){
     
    if(u==n){
     
        for(auto x:path) cout<<x<<" ";
        cout<<endl;
        return ;
    }
    
    for(int i=0;i<n;i++){
     //每一个坑都遍历1-n个数字
        if(!(state>>i&1)){
     //如果这个数字没有选过
            path.push_back(i+1);
            dfs(u+1,state+(1<<i));//在坑上填如当前数字，并递归到下一个坑
            path.pop_back();//恢复现场
        }
    }
    
}


int main(){
     
    cin>>n;
    dfs(0,0);
    return 0;
}

4、递归实现排列型枚举

题目：你玩过“拉灯”游戏吗？25盏灯排成一个5x5的方形。每一个灯都有一个开关，游戏者可以改变它的状态。每一步，游戏者可以改变某一个灯的状态。游戏者改变一个灯的状态会产生连锁反应：和这个灯上下左右相邻的灯也要相应地改变其状态。

我们用数字“1”表示一盏开着的灯，用数字“0”表示关着的灯。下面这种状态

10111
01101
10111
10000
11011
在改变了最左上角的灯的状态后将变成：

01111
11101
10111
10000
11011
再改变它正中间的灯后状态将变成：

01111
11001
11001
10100
11011
给定一些游戏的初始状态，编写程序判断游戏者是否可能在6步以内使所有的灯都变亮。

输入格式
第一行输入正整数n，代表数据中共有n个待解决的游戏初始状态。

以下若干行数据分为n组，每组数据有5行，每行5个字符。每组数据描述了一个游戏的初始状态。各组数据间用一个空行分隔。

输出格式
一共输出n行数据，每行有一个小于等于6的整数，它表示对于输入数据中对应的游戏状态最少需要几步才能使所有灯变亮。

对于某一个游戏初始状态，若6步以内无法使所有灯变亮，则输出“-1”。

数据范围 0 输入样例：
3
00111
01011
10001
11010
11100

11101
11101
11110
11111
11111

01111
11111
11111
11111
11111

输出样例：
3
2
-1

思路：

我们来随便画一个5*5的棋盘来观察一下状态，灰色表示没亮的部分，棋盘的每一个位置都有按一下和不按两种选择，暴力枚举当然可以是解题方法，但是2^25数量级肯定过不了时间限制

再来看这个棋盘，我们可以枚举第一行的32种操作，当然每个位置只操作一次，如果操作两次的话相当于没有操作纯属浪费步数，那么比如操作了第二位和第五位之后，棋盘变成了

此时第一行已经是操作之后的了，不可以在对第一行进行操作了，那么想得到最终全亮的结果，必须操作第二行让第一行全亮，即第一行暗的地方的下面必须被操作一次，操作后结果为：

同理操作第3，4，5行，可以看出，第一行的操作确定了之后，那么后面的四行的操作就也唯一确定，如果在操作完了第5行之后，第5行不是全亮状态，那么就说明该棋盘状态是无解的。

代码：

#include
#include

using namespace std;

const int INF=10000;

char g[10][10];
int dx[5]={
     0,-1,0,1,0},dy[5]={
     0,0,1,0,-1};//当前 上 右 下 左

//按按钮
void turn(int x,int y){
     
    for(int i=0;i<5;i++){
     
        int a=x+dx[i],b=y+dy[i];
        if(a>=0&&a<5&&b>=0&&b<5){
     
            g[a][b] ^= 1;//异或 表示该位取反
        }
    }
}

int work(){
     
    int ans=INF;
    for(int k=0;k<1<<5;k++){
     //操作第一行，第一行有32种操作方法，每一位有按与不按两种做法，全部尝试一遍
        char backup[10][10];
        int res=0;
        memcpy(backup,g,sizeof g);//把g数组copy一份到backup中去
        for(int j=0;j<5;j++)//第一行从第一位到第5位
            if(k>>j&1){
     //如果第一行该位为1,则按下这个按钮，这样可以最小操作
                res++;
                turn(0,j);
            }
            
            
        for(int i=0;i<4;i++)//遍历前1-n-1行，操作第2-n行
            for(int j=0;j<5;j++)
                if(g[i][j]=='0'){
     
                    res++;
                    turn(i+1,j);//该位为0,则按下一行该位按钮
                }
            
        bool is_successful=true;
        
        for(int j=0;j<5;j++)
            if(g[4][j]=='0')//遍历最后一行，如果存在0,则失败
            {
     
                is_successful=false;
                break;
            }
        
        if (is_successful) ans = min(ans, res);
        
        memcpy(g,backup,sizeof g);//把存下来的初始情况又赋值回g数组中重新一轮从第一行开始按键
        
    }
    
    if (ans > 6) return -1;
    return ans;
}


int main()
{
     
    int T;
    cin >> T;
    while (T -- )
    {
     
        for (int i = 0; i < 5; i ++ ) cin >> g[i];
        cout << work() << endl;
    }
    return 0;
}

5、奇怪的汉诺塔

题目：汉诺塔问题，条件如下：

1、这里有A、B、C和D四座塔。

2、这里有n个圆盘，n的数量是恒定的。

3、每个圆盘的尺寸都不相同。

4、所有的圆盘在开始时都堆叠在塔A上，且圆盘尺寸从塔顶到塔底逐渐增大。

5、我们需要将所有的圆盘都从塔A转移到塔D上。

6、每次可以移动一个圆盘，当塔为空塔或者塔顶圆盘尺寸大于被移动圆盘时，可将圆盘移至这座塔上。

请你求出将所有圆盘从塔A移动到塔D，所需的最小移动次数是多少。

汉诺塔塔参考模型

思路： DP+递推

首先，我们可以初步确定，这是一道递归/递推的题目。（因为是汉诺塔问题）
我们先考虑三个塔的汉诺塔问题，最优秀方案：必然是先挪走n-1个圆盘，然后再挪走圆盘N，
因此可以得出递推方程也就是 d[i]=d[i-1]*2+1;
之所以要乘以2，是因为第一次挪到第二个塔，然后还要挪移回到第三个塔，下面四个塔也是这样的
接着考虑四塔问题，我们可以这么思考，首先挪走j个塔，也就是有四个塔可以选择，然后再挪走剩下的n-j个塔，此时有三个塔可以选择，因此这就是我们的状态转移方程：f[i]=min(f[i],f[j]*2+d[n-j]);//i表示当前一共有几个塔，也就是上文所说的n

代码

#include
#include
#include

using namespace std;

int d[15],f[15];
int main(){
     
    
    //3根柱子的转移情况
    d[1]=1;//一个盘子转一次
    for(int i=2;i<=12;i++)
        d[i]=1+d[i-1]*2;  //将前i-1个盘子移到第2根柱子上为d[i-1]，再把最后一个盘子移到第3根柱子上为一次,再把第2根柱子上的i-1个盘子移到第3根柱子上为d[i-1]
        
    memset(f,0x3f,sizeof(f));//将f赋值为一个非常大的数字，而且2倍的f不会溢出
    
    f[0]=0;
    for(int i=1;i<=12;i++)
        for(int j=0;j<i;j++)//先操作前j个盘子
        //先把前j个盘子放到某根棍子上为f[j]
        //在把剩下i-j个盘子移到第四根棍子上(这里只能操作3根棍子，不能放到前j个盘子的那根棍子上，因为盘子更大) 为d[i-j]
        //最后把前j个盘子移到第四根棍子上为f[j]  
            f[i]=min(f[i],f[j]*2+d[i-j]);
    for(int i=1;i<=12;i++)
        cout<<f[i]<<endl;
}

6、约数之和

题目：
假设现在有两个自然数A和B，S是AB的所有约数之和。
请你求出S mod 9901的值是多少。

输入格式
在一行中输入用空格隔开的两个整数A和B。

输出格式
输出一个整数，代表S mod 9901的值。

数据范围 0≤A,B≤5×1070≤A,B≤5×107

输入样例：
2 3
输出样例：
15
注意: A和B不会同时为0。

思路： 数学(质因数分解，唯一分解定律，约数和公式)，分治递归

• 因数分解，就是将一个数分解成为 $p_1^{c1}\times p_2^{c_2}\times \dots \times p_n^{c_n}$ 比如说，$24=2^3\times 3^1$
  约数和公式，如下文所示
  $A^B=\left(1+p_1^1+p_1^2+\dots .+p_1^{B\ast c_1}\right)\times \left(1+p_2^2+\dots ..+p_n^{B\times c_2}\right)$
  其展开可以得到(k1+1)(k2+1)…(kn+1)个数之和，也就是A的约数之和。
• $\mathrm{sum}(p,c)=1+p+p^2+\dots +p^c$
  一共k+1项，我们对k分类讨论，k为奇数时，k+1为偶数，例如k = 7，sum(p,7) = (p ^ 0 + p ^ 1 + p ^ 2 + p ^ 3 ) + (p ^ 4 + p ^ 5 + p ^ 6 + p^7)。
• 我们对其分成数量相等的两组式子，又p ^ 4 + p ^ 5 + p ^ 6 + p ^ 7 = p^4 * (p^0 + p^1 + p^2 + p^3 ),所以sum(p,7) = (p^0 + p^1 + p^2 + p^3 ) * (1 + p ^ 4).更一般的，sum(p,k) = (p ^ 0 + p ^ 1 + … + p^k/2 ) * (1 + p^(k/2+1) ) = sum(p,k/2) * (1 + p^(k/2+1) ) ，其中k为奇数。
• k为偶数时，k+1为奇数，sum(p,k) = p ^ 0 + p ^ 1 + … + p^k = 1 + p * (p^0 + p ^1 + … + p^(k-1) ) = 1 + p * sum(p,k-1).
  当然，最后需要注意的是，我们求A^B的约数和时，调用的sum（p，k），k应该是第一步推导的kB。并且k为奇数时，我们求幂可以使用快速幂算法。

快速幂模板
一个b进制数的值可以表示为各个数位的值与权值之积的总和。比如，2进制数1001，它的值可以表示为10进制的1×23+0×22+0×21+1×20，即9。

求 m^k mod p，时间复杂度 O(logk)。

int qmi(int m, int k, int p)
{
     
    int res = 1 % p, t = m;
    while (k)
    {
     
        if (k&1) res = res * t % p;
        t = t * t % p;
        k >>= 1;
    }
    return res;
}

代码

#include

using namespace std;

const int mod=9901;

int qmi(int a,int k){
     
    a%=mod;
    
    int res=1;
    while(k){
     
        if(k&1)res=res*a%mod;
        a=a*a%mod;
        k>>=1;
    }
    return res;
}

int sum(int p,int k){
     
    if(k==0)return 1;
    if(k%2==0)return (p%mod*sum(p,k-1)%mod+1)%mod;
    return sum(p,k/2)%mod*(1+qmi(p,k/2+1))%mod;
}

int main(){
     
    int A,B;
    cin>>A>>B;
    
    int res=1;
    for(int i=2;i<=A;i++){
     
        int s=0;
        while(A%i==0){
     
            s++;
            A/=i;
        }
        
        if(s)res=res*sum(i,s*B)%mod;
    }
    
    if(!A) res=0;//特判
    cout<<res<<endl;
    return 0;
}