【算法笔记】4.3递归

4.3递归

本系列为《算法笔记》刷题记录，记录自己有思考的错的地方，版子题不多解释只放代码。

就是将问题分解处理，解题主要考虑两点：

• 终止条件
• 问题分解

回溯

递归过程中，使用条件判断，不满足条件时，不再继续向下递归，这种过程叫回溯。

问题 D: 八皇后

会下国际象棋的人都很清楚：皇后可以在横、竖、斜线上不限步数地吃掉其他棋子。如何将8个皇后放在棋盘上（有8 * 8个方格），使它们谁也不能被吃掉！这就是著名的八皇后问题。
对于某个满足要求的8皇后的摆放方法，定义一个皇后串a与之对应，即a=b1b2…b8，其中bi为相应摆法中第i行皇后所处的列数。已经知道8皇后问题一共有92组解（即92个不同的皇后串）。
给出一个数b，要求输出第b个串。串的比较是这样的：皇后串x置于皇后串y之前，当且仅当将x视为整数时比y小。

通过条件分析可以得到每行、每列最多一个皇后，因此主要判断斜线上不能有两个；遍历每行，罗列 列上可能的排列，判断是否满足条件来解。

判断斜线

利用坐标系思想，把棋盘看做坐标轴，在一条斜线上意味着斜率为1/-1，也就是对点$(x_1,y_1),(x_2,y_2)==>abs(x_1-x_2)=abs(y_1-y_2)$ ；

出错点是generate里面的i部分是行还是列，generate遍历每一行，i表示的是列，pre是前面的行，写式子的时候注意这点。

vector<int> v;
int place[10]={0};
bool haveone[10]={false};
// int n;
const int maxn=9;
void generate(int row){
    if(row==maxn){
        int ans=0;
        for(int i=1;i<9;i++) ans=ans*10+place[i];
        v.push_back(ans);
        return;
    }
    for(int i=1;i<maxn;i++){//i==column
        if(!haveone[i]){
            bool flag=true;
            for(int pre=1;pre<row;pre++){
                if(abs(row-pre)==abs(i-place[pre])){
                    flag=false;
                    break;
                }
            }
            if(flag){
                place[row]=i;
                haveone[i]=true;
                generate(row+1);
                haveone[i]=false;
            }  
        }
    }
    return;
}
int main(){
    int n,x;
    cin>>n;
    generate(1);
    // cout<<v.size()<<"===\n";
    // sort(v.begin(),v.end());
    while (n--)
    {
        cin>>x;
        cout<<v[x-1]<<"\n";
    }
    return 0;
}

问题 C: 神奇的口袋

有一个神奇的口袋，总的容积是40，用这个口袋可以变出一些物品，这些物品的总体积必须是40。John现在有n个想要得到的物品，每个物品的体积分别是a1，a2……an。John可以从这些物品中选择一些，如果选出的物体的总体积是40，那么利用这个神奇的口袋，John就可以得到这些物品。现在的问题是，John有多少种不同的选择物品的方式。

每个物体选择拿或者不拿，来递归；注意不拿后也要继续递归再写一个递归式子

int ans=0,cnt=0;
vector<int> bag;
int n;
void take(int x){
    if(x==n){
        if(cnt==40) ans++;
        return;
    }
    cnt+=bag[x];
    take(x+1);
    cnt-=bag[x];
    take(x+1);//不拿递归
    return;
}
int main(){
    int t;
    while (cin>>n)
    {
        bag.clear();
        ans=0,cnt=0;
        for(int i=0;i<n;i++){
            cin>>t;
            bag.push_back(t);
        }
        take(0);
        cout<<ans<<"\n";
    }
    return 0;
}

问题 B: 数列

编写一个求斐波那契数列的递归函数，输入n 值，使用该递归函数，输出如下图形（参见样例）。

观察是每行满足斐波那契数列，数字的个数和每行空格的个数有规律，思路为提前求出斐波那契数列存在数组中，避免重读求解；然后按照金字塔输出形状，具体规律为：

对称轴之前有2n个坑，每两个坑算作一组，一组填充” “或者”x “；对称轴之前有row个数坑，n-row个空格坑，先输出空格坑，然后按照斐波那契数组输出数坑

int fb[12];
void generate(int n)
{
    if (n == 0 || n == 1)
    {
        fb[n] = n;
    }
    else
    {
        if (!fb[n - 1])
            generate(n - 1);
        if (!fb[n - 2])
            generate(n - 2);
        if (!fb[n])
            fb[n] = fb[n - 1] + fb[n - 2];
    }
    return;
}
int main()
{
    int m, n;
    cin >> m;
    while (m--)
    {
        cin >> n;
        generate(1+(n-1)*2);
        for (int line = 1; line <= n; line++)
        {
            int total = 1 + (line - 1) * 2;
            for (int i = 1; i <= n - line; i++)
            {
                cout << "  ";
            }
            for (int i = 0; i < total; i++)
            {
                cout << fb[i];
                if (i < total - 1)
                    cout << " ";
            }
            cout<<"\n";
        }
    }
}

问题 A: 吃糖果

名名的妈妈从外地出差回来，带了一盒好吃又精美的巧克力给名名（盒内共有 N 块巧克力，20 > N >0）。
妈妈告诉名名每天可以吃一块或者两块巧克力。
假设名名每天都吃巧克力，问名名共有多少种不同的吃完巧克力的方案。

int eat(int N){
    int cnt=0;
    if(N==0) return 1;
    else{
        cnt+=eat(N-1);
        if(N>1) cnt+=eat(N-2);
    }
    return cnt;
}
int main(){
    int N;
    int ans=0;
    while (cin>>N)
    {
        ans=eat(N);
        cout<<ans<<"\n";
    }
    return 0;
}