递推与递归

92. 递归实现指数型枚举 - AcWing题库

#include <bits/stdc++.h>
using namespace std;
const int N=17;
int n;
bool vis[N];//记录某一个数是否出现过
void dfs(int dep){
  // if(vis[dep])continue;//没有这一句 因为一定不会有已经选过的数
  if(dep==n+1){//对于每个数都做完了选与不选的决定
    for(int i=1;i<=n;i++){
      if(vis[i])cout<<i<<' ';
    }
    cout<<'\n';
    return ;//记得要return
  }
  vis[dep]=1;
  dfs(dep+1);
  vis[dep]=0;
  dfs(dep+1);
}
int main(){
  cin>>n;
  dfs(1);
  return 0;
}

93. 递归实现组合型枚举 - AcWing题库

#include <bits/stdc++.h>
using namespace std;
const int N=100;
int a[N];
int n,m;//n个数中选择m个
int vis[N];
void dfs(int dep,int st){//st数组是为了保证顺序每次只往后面找
    if(dep==m+1){//选够m个数了 该选第m+1个数了
        for(int i=1;i<=n;i++){
            if(vis[i]==1)cout<<a[i]<<" ";
        }
        cout<<'\n';
        return ;
    }
    for(int i=st;i<=n;i++){
        if(!vis[i]){
        vis[i]=1;//这层有一个数 才去搜索下一层(重要)
        dfs(dep+1,i+1);//这里是i+1 因为第i个数字做出判断之后下次要判断的应该是它后面的数
        vis[i]=0;
        }
    }
}
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++)a[i]=i;
    dfs(1,1);
    return 0;
}

94. 递归实现排列型枚举 - AcWing题库

#include <bits/stdc++.h>
using namespace std;
const int N=17;
int n;
bool vis[N]={};//记录某一个数是否出现过
vector<int>ans;
void dfs(int dep){//这里的dep表示的是够多少个数
  if(dep==n+1){
    for(auto i:ans)cout<<i<<' ';
    cout <<'\n';
    return ;
  }
  for(int i=1;i<=n;i++){
    if(vis[i])continue;
    vis[i]=1;
    ans.push_back(i);
    dfs(dep+1);//这里要是搜索下一个位置 一定要是dep+1
    vis[i]=0;
    ans.pop_back();
  }
}
int main(){
  cin>>n;
  dfs(1);
  return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int N=17;
int n;
bool vis[N]={};//记录某一个数是否出现过
vector<int>ans;
void dfs(int dep,int st){//这里的dep表示的是够多少个数
  if(dep==n+1){
    for(auto i:ans)cout<<i<<' ';
    cout <<'\n';
    return ;
  }
  for(int i=st;i<=n;i++){
    if(vis[i])continue;
    vis[i]=1;
    ans.push_back(i);
    dfs(dep+1,st+1);//这里要是搜索下一个位置 一定要是dep+1
    vis[i]=0;
    ans.pop_back();
  }
}//这样的意思是从第一个数开始搜 答案一定要够n个数才能输出
int main(){
  cin>>n;
  dfs(1,1);
  return 0;
}

1537. 递归实现排列类型枚举 II - AcWing题库

#include <bits/stdc++.h>
using namespace std;
const int N=12;
int a[N],vis[N];
int n;
vector<int>ans;
void dfs(int dep){
    if(dep==n+1){
        for(int i=0;i<n;i++)cout<<ans[i]<<" \n"[i==n-1];
        return ;
    }
    for(int i=1;i<=n;i++){
        if(!vis[i]){
        vis[i]=1;
        ans.push_back(a[i]);
        dfs(dep+1);
        ans.pop_back();
        vis[i]=0;
        while(a[i + 1] == a[i]) i++;//剪去重复的 每一个数后面会分出来不同的枝，
        //使相同的数分出来的相同枝只出现一次，可以避免重复输出
        }
    }
    return ;
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++)cin>>a[i];
    sort(a+1,a+n+1);
    dfs(1);
    return 0;
}

717. 简单斐波那契 - AcWing题库

#include <bits/stdc++.h>
using namespace std;
int n,q;
const int N=100007;
int a[N];
int dp[N];
void solve(){
  dp[1]=0;
  dp[2]=1;
  dp[3]=1;
  for(int i=4;i<=n;i++)dp[i]=dp[i-1]+dp[i-2];
  for(int i=1;i<=n;i++)cout<<dp[i]<<' ';
}
int main(){
  int t=1;
  cin>>n;
  while(t--)solve();
  return 0;
}

唯一分解定理：一个数可以由若干个质数的若干次方相乘得到

也可以通过若干个2的次方相加得到

95. 费解的开关 - AcWing题库

好难啊这题我哭死了

#include <bits/stdc++.h>
using namespace std;

const int N = 6;
int dx[N] = {-1, 0, 1, 0, 0}, dy[N] = {0, 1, 0, -1, 0};
char g[N][N], backup[N][N];


// 这个操作是把(x, y)以及上下左右的灯都变成相反的颜色
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) continue;

        g[a][b] ^= 1;   //异或，不同的时候就变成相反的数
        //同0异1
    }

}


int main()
{
    int n;
    scanf("%d", &n);
    while(n -- )
    {
        // 按行输入，把每一行当成一个字符串
        for (int i = 0; i < 5; i ++ ) cin >> g[i];

        int res = 0x3f3f;

        // 这里我们枚举了第一行的32种按法，不用管是亮是灭，把第一行所有情况都按一遍
        // 按每种情况的第一行，去遍历接下来的行
        // 枚举32种第一行的按法只是可能会减少步数，如果直接从第二行开始答案一定是固定的了，找不到最优解或者可能没有解

//枚举第一行的意义是：不需要在意第一行的灯是灭是暗，只需把第一行的按法枚举一遍，也就是我们说的 "操作"，
//每个位置都有两种选择，按(用1表示)或者不按(用0表示)，遍历这32种操作引发的情况，
//每一次再通过res = min(res, step);把最小步数存一下，就能找到最优解
        for (int op = 0; op < 32; op ++ ){//枚举第一行每一种状态 //好好想想这里为什么要是<32：11111是31 
//是说我们输入的已知的是第一行灯亮或暗的状态，而我们枚举的32种是我们对灯的操作，按还是不按。
            // 我在对这种情况操作的时候，得先备用一下
            // 把原始数组备份一下，然后操作g，操作完了还原，然后再操作
            memcpy(backup, g, sizeof g);

            int step = 0;

            // 第一行的按法(在这里 1 表示按了, 0 表示不按)，这里只是为了输出第一行按完之后的状态
            for (int i = 0; i < 5; i ++ )
                if (op >> i & 1)  // 数字2 对应了 00010 表示第2个位置的按一下
                                  // 00010 >> 1 & 1  是1 所以turn(0, 1) 就是第一行第二个位置
                {                 // 数字3 对应了00011 表示第1 和第2个位置的按一下
                    step ++ ;
                    turn (0, i);;
                }

            // 然后通过第一行按完之后的状态，按234行
            for (int i =0; i < 4; i ++ )
                for (int j = 0; j < 5;j ++ )
                    if (g[i][j] == '0')
                    {
                        step ++;
                        turn (i + 1, j);  // 如果这个位置是灭的，就按下一行对应的位置
                    }

            bool dark = false;
            for (int j = 0; j < 5; j ++ )
                if (g[4][j] == '0')
                {
                    dark = true;
                    break;
                }


            // 对于32种情况的这一种，如果所有的全亮就记录下步数(事实上只记录了最后一行是否dark)
            if (!dark) res = min(res, step);
            memcpy (g, backup, sizeof g);
        }

        if(res > 6) res = -1;
        cout << res << endl;

    }
    return 0;
}

116. 飞行员兄弟 - AcWing题库

//一个把手改变，会使所在行列的所有把手全部反转
//特点：①在最优解里面每个把手只按一次，按两次没有区别，
//②按的顺序无关紧要，最终取决于这个把手按的次数！！！
//思考这个题可以递推出来吗？  答案是：很难
//可以想一想，前面的题都是通过某种顺序，每一次都是影响一个灯泡，但是这个题
//不能使用前面的办法，因为操作一次会影响好多灯泡。所以想一想朴素做法

//我们发现这个题的数据范围很小，所以尝试用暴力解决ac
//暴力思路：①16个开关，所有开关的状态数量想一想是多少？ 答案是2^16！这个我感觉
//我这么笨还是可以想出来的，往后怎么想呢？
//状态数量即最大操作次数2^16（65536）,既然也不大，那就①枚举所有的方案，
//然后按照这个方案来操作
//②如果可以实现把手全开，证明此方案合法
//③然后统计这个方案里面需要操作的把手数量
//④在所有能按的开关数量里取一个最小值
//ac
//输出方案注意:若两种方案步数相同，按字典序（先按横坐标排序，再按纵坐标排序）


#include <bits/stdc++.h>
//这个宏定义其实也就最后输出的时候应用了（如果我没猜错的话），但是y总的习惯就是好习惯！
#define x first
#define y second

using namespace std;

typedef pair<int,int> PII;

const int N=5;

char g[N][N],backup[N][N];


//映射函数
int get(int x,int y){
    return x*4+y;//返回第x行第y列上的数是多少
}

void turn_one(int x,int y){
    if(g[x][y]=='+') g[x][y]='-';
    else g[x][y]='+';
}

void turn_all(int x,int y){
    for(int i=0;i<4;i++)
    {
        turn_one(x,i);//关闭这一行所有的 
        turn_one(i,y);//关闭这一列的全部
		//xy被关闭了两次 相当于没变 
    }
    turn_one(x,y);//对xy也要改变 

}

int main(){
    for(int i=0;i<4;i++)
        for(int j=0;j<4;j++)
            cin>>g[i][j];

    vector<PII> res;//这是记录方案所需要的结构

    //枚举所有的方案
    for(int op=0;op<(1<<16);op++){//枚举每一种方案 1代表我们要去操作那个灯
	 
        vector<PII> temp;//temp里面存的是方案
        //先备份一下，为什么？因为这又不是最终方案，我们要把所有方案都试一遍，求最少的
        memcpy(backup,g,sizeof g);

        //枚举16个位置,进行操作
        for(int i=0;i<4;i++)
            for(int j=0;j<4;j++)
                if(op>>get(i,j)&1) //如果当前位置是1(我们在方案中准备操作)的话--get的作用就是返回二进制数中那一位是第几位，从而判断是否为1
                {
                    temp.push_back({i,j});
                    //按一下开关
                    turn_all(i,j);
                }


        //判断所有灯泡是否全亮
        bool has_closed=false;
        for(int i=0;i<4;i++)
            for(int j=0;j<4;j++)
                if(g[i][j]=='+') has_closed=true;

        if(has_closed==false)
        {
            //如果方案为空或者他的操作数大于我们刚存好的新的方案，那么就修改它
            if(res.empty()||res.size()>temp.size()) res=temp;
        }
        //还原回来，供下一个方案操作
        memcpy(g,backup,sizeof g);
    }
    
    //因为没说无解，所以可以猜想一下一定有解
    cout<<res.size()<<'\n';
    //这里的迭代函数就是一种简便写法，不要误解
    //另外原题下标从1开始，所以下面加1了
    for(auto op:res) cout<<op.x+1<<" "<<op.y+1<<'\n';

    //for(int i=0;i<res.size();i++){
    //	cout<<res[i].x+1<<" "<<res[i].y+1<<'\n';
	//}
    return 0;
}

1208. 翻硬币 - AcWing题库

#include <bits/stdc++.h>
using namespace std;
const int N=107;
char change(char &ch){
    if(ch=='*') return 'o';
    return '*';
}

char a[N];
char b[N];
int main(){
  //读不进去可以尝试 cin>>s+1,cin>>s,cin.ignore(),getline(cin,a),cin.getline(a,N);
    cin.getline(a,N);
    cin.getline(b,N);
    // cin>>(a+1);
    // cin>>(b+1);
    int n = strlen(a);
    int step = 0;
    for(int i = 0; i < n; i++){
        if(a[i] != b[i]){
            a[i] = change(a[i]);
            if(i+1 < n) {
                a[i+1] = change(a[i+1]);
            }
            step++;
        }
    }
    cout << step;
    return 0;
}