Treinamento especial do AcWing Blue Bridge Cup: (1) Exemplos de recursão e recursão

Treinamento especial do AcWing Blue Bridge Cup: (1) Exemplos de recursão e recursão

ID da conta AcWing: Koji Tiansuo

Nota: pode ser diferente do código total de y

92. Implemente recursivamente a enumeração exponencial (mestre),
    selecione aleatoriamente qualquer número de n inteiros de 1 a n, e a questão finalmente exige que enviemos em ordem crescente.
    Na classe geral y, é claramente indicado que podemos usar o diagrama de árvore para considerar.Para cada dígito, podemos derivar dois casos de seleção e não seleção. Depois de considerar os dois casos, consideraremos os deles da mesma forma. Selecione e desmarque o próximo dígito ... e assim por diante. Desde que esses dois casos sejam considerados separadamente, preste atenção à redução recursiva .

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
const int N=16;
int n;
vector<int>path;//记录最终答案

void dfs(int u)//u代表了当前是1-n中的哪一个数，由于输出需要从小到大，故从1开始
{
    
    
    if(u == n+1)//如果这n位数都枚举完了，显然是枚举到第n+1个了
    {
    
    
        for(int i=0;i<path.size();i++)
        {
    
    
            cout<<path[i]<<" ";
        }
        cout<<endl;
        return ;//递归终止，开始回溯
    }
 
    path.push_back(u);
    dfs(u+1);//如果选了本位数，就push进去
    path.pop_back();//递归还原
    
    dfs(u+1);//如果没选本位数。
}
int main()
{
    
    
    cin>>n;
    dfs(1);
    return 0;
}

94. O problema de implementar recursivamente a enumeração exponencial (mastering)
    exige que interrompamos a ordem de 1-n e, ao mesmo tempo, que a ordem lexicográfica menor venha primeiro. Então usamos para para enumerar cada dígito em nosso 1-ne marcar que usamos esse dígito. Aqui usamos uma ideia recursiva para resolver:
    Pegue o exemplo de i = 1 bit, pegamos o primeiro número Depois de escolher i = 1 e colocá-lo na matriz de caminho, passamos recursivamente para o próximo nível, escolhendo um número de i = 2-> n.
    Da mesma forma, também podemos escolher not i = 1 para o primeiro nível de recursão. Por meio de for, podemos escolher i = 2,3 ... n como o primeiro número e marcá-lo para evitar a repetição e, em seguida, retornar ao próximo nível que nunca foi marcado. O vencedor é o próximo dígito. Também preste atenção à restauração recursiva !

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
const int N=10;
int n;
vector<int>path;
bool st[N];

void dfs(int u)
{
    
    
    if(u == n)
    {
    
    
        for(int i=0;i<path.size();i++)
        {
    
    
            cout<<path[i]<<" ";
        }
        cout<<endl;
        return ;
    }
    for(int i=1;i<=n;i++)
    {
    
    
        if(!st[i])
        {
    
    
            path.push_back(i);
            st[i]=true;
            dfs(u+1);
            st[i]=false;
            path.pop_back();
        }
    }
}
int main()
{
    
    
    cin>>n;
    dfs(0);
    return 0;
}

717. 
     Não há nada a dizer sobre o problema da sequência de Fibonacci (mestre) , apenas recursão comum.

#include<bits/stdc++.h>
using namespace std;
int a[100010];
int main()
{
    
    
    int n;
    cin>>n;
    if(n==1)
    {
    
    
        cout<<"0"<<endl;
    }
    else
    {
    
    
    a[0]=0;
    a[1]=1;
    cout<<"0"<<" "<<"1"<<" ";
    for(int i=2;i<=n-1;i++)
    {
    
    
        a[i]=a[i-1]+a[i-2];
        cout<<a[i]<<" ";
    }
    cout<<endl;
    }
    return 0;
}

95. Troca inexplicável (tente entender)
    a ideia central desta pergunta é: em
    primeiro lugar, cada grade realmente precisa ser clicada. Se você pressionar um número par, ele não terá efeito. Se você pressionar um número ímpar, é equivalente a um número par +1, que é o mesmo que pressionar. Não cumpre o princípio dos passos mínimos.
    Ao mesmo tempo, o ligar / desligar da lâmpada é equivalente a 0/1 em binário, podemos controlar o desligar e ligar a luz por meio de operação de bit.

//首先每个格子都只能按一下，如果按偶数下那么没有效果，如果按技术下，又和1下相同，不符合最小步数原理
#include<bits/stdc++.h>
using namespace std;
const int N=6;
char g[N][N],backup[N][N];
int dx[5]={
    
    -1,0,1,0,0};
int dy[5]={
    
    0,1,0,-1,0};
void turn(int x,int y)
{
    
    
    for(int i=0;i<5;i++)
    {
    
    
        int a=x+dx[i];
        int b=y+dy[i];//二进制48 49 分别为110000，110001，只差1，所以可以亦或
    if(a<0||a>=5||b<0||b>=5)
    {
    
    continue;}
    g[a][b]^=1;
    }//由于字符型0的asicii值为48，1的为49,亦或即便为对位上的相反的数，所以只有最后一位对位相反
}
int main()
{
    
    
    int T;
    cin>>T;
    while(T--)
    {
    
    
        for(int i=0;i<5;i++)
        {
    
    
            cin>>g[i];
        }
        int res=10;//最大步数
        for(int op=0;op<32;op++)//第一行可以变成32种可能性，依据按与不按分为32种情况，设1为可以0为不可以
        {
    
    //例如10001为操作第一位和最后一位
            memcpy(backup,g,sizeof g);
            int step=0;
            for(int i=0;i<5;i++)
            {
    
    
                if(op>>i&1)//二进制位运算，代表着如果op的二进制数中为0则不操作，为1则可操作（选或不选问题）
                {
    
    //所以对5位二进制数的每一位枚举只要有一就改变
                    step++;
                    turn(0,i);//改变原有的亮光程度
                }
            }
            for(int i=0;i<4;i++)//一次枚举剩下的4x5
            {
    
    
                for(int j=0;j<5;j++)
                {
    
    
                    if(g[i][j]=='0')
                    {
    
    
                        step++;
                        turn(i+1,j);//下面决定上面，当上面有0的时候，摁下面
                    }
                }
            }
            bool dark=false;
            for(int i=0;i<5;i++)
            {
    
    
                if(g[4][i]=='0')
                {
    
    
                    dark=true;
                    break;
                }
            }
            if(!dark)
            {
    
    
                res=min(res,step);
            }
            memcpy(g,backup,sizeof g);//还原
        }
        if(res>6)
        {
    
    
            cout<<"-1"<<endl;
        }
        else
        {
    
    
            cout<<res<<endl;
        }
    }
    return 0;
}