基本算法(C++)总结与练习

1、飞行员兄弟

题目：“飞行员兄弟”这个游戏，需要玩家顺利的打开一个拥有16个把手的冰箱。

已知每个把手可以处于以下两种状态之一：打开或关闭。

只有当所有把手都打开时，冰箱才会打开。

把手可以表示为一个4х4的矩阵，您可以改变任何一个位置[i,j]上把手的状态。

但是，这也会使得第i行和第j列上的所有把手的状态也随着改变。

请你求出打开冰箱所需的切换把手的次数最小值是多少。

输入格式
输入一共包含四行，每行包含四个把手的初始状态。

符号“+”表示把手处于闭合状态，而符号“-”表示把手处于打开状态。

至少一个手柄的初始状态是关闭的。

输出格式
第一行输出一个整数N，表示所需的最小切换把手次数。

接下来N行描述切换顺序，每行输入两个整数，代表被切换状态的把手的行号和列号，数字之间用空格隔开。

注意：如果存在多种打开冰箱的方式，则按照优先级整体从上到下，同行从左到右打开。

数据范围
1≤i,j≤4

思路：枚举+位运算

不需要DFS。枚举每一个位置是否应该被按（000…001 –> 111…111），这个枚举默认了每个位置最多按一次，这就是解空间。
枚举解空间并进行遍历处理即可，注意一行一列变换的时候，中心点只能变换一次。
因为只涉及到16个位置，所以用一个变量state就能够存储所有位置的状态, 所以可以不用开数组(虽说开数组的开销也很小)

时间复杂度分析：枚举状态一共O(216)O(216)，每轮处理16个bit里面对应的操作，最终复杂度应该是O(16∗216

#include
#include
#include

using namespace std;;

typedef pair<int,int> PII;

int change[4][4];

int get(int x,int y){
   
    return x*4+y;//计算每个位置的偏移量
}

int main(){
   
    int state=0;//记录表示所有开关状态的16位数，0表示该位打开，1表示关闭
    for(int i=0;i<4;i++){
   
        string line;
        cin>>line;
        for(int j=0;j<4;j++)
            if(line[j]=='+')
                state+= 1<<get(i,j);//state用一个整数表示整个矩形的状态
    }
    
    for(int i=0;i<4;i++)
        for(int j=0;j<4;j++){
   
            for(int k=0;k<4;k++){
   //对该矩阵的每一位进行操作，
                change[i][j]+=1<<get(i,k);//该位对应的该行的所有位置进行+2^get(i,k)
                change[i][j]+=1<<get(k,j);//该位对应的该列的所有位置进行+2^get(k,j)
            }
            change[i][j]-=1<<get(i,j);//该位被加了两次，则需要减掉一次
        }
        
    vector<PII> res;//保存方案
    for(int k=0;k<1<<16;k++){
   //枚举0——2^16-1个方案
        int now=state;//用一个变量来保存当前的局面，初始状态不能改变
        vector<PII> path;//对于每种方案需要把操作记录下来
        for(int i=0;i<16;i++){
   //枚举16位哪一位需要操作
            if(k>>i&1)//如果k的某一位是1则该位需要操作
            {
   
                int x=i/4,y=i%4;//编号为i的下标
                now^=change[x][y];//对下标为[x][y]的位置进行操作，直接亦或 之前记录的每个位置进行操作的数
                path.push_back({
   x,y});
            }
        }
        //判断该方案是否合法
        if(!now&&(res.empty()||res.size()>path.size()))
        //该方案最后now为0并且，如果是第一次保存则直接保存，如果后续的方案比之前保存的操作次数小则更新res
            res=path;
    }
    
    cout<<res.size()<<endl;
    for(auto p:res)cout<<p.first+1<<' '<<p.second+1<<endl;
}

2、占卜

题目：
达达学会了使用扑克DIY占卜。

方法如下：

一副去掉大小王的扑克共52张，打乱后均分为13堆，编号1~13，每堆4张，其中第13堆称作“生命牌”，也就是说你有4条命。

这里边，4张K被称作死神。

初始状态下，所有的牌背面朝上扣下。

流程如下：

1.抽取生命牌中的最上面一张(第一张)。

2.把这张牌翻开，正面朝上，放到牌上的数字所对应编号的堆的最上边。(例如抽到2，正面朝上放到第2堆牌最上面，又比如抽到J，放到第11堆牌最上边，注意是正面朝上放)

3.从刚放了牌的那一堆最底下(最后一张)抽取一张牌，重复第2步。（例如你上次抽了2，放到了第二堆顶部，现在抽第二堆最后一张发现是8，又放到第8堆顶部…）

4.在抽牌过程中如果抽到K，则称死了一条命，就扔掉K再从第1步开始。

5.当发现四条命都死了以后，统计现在每堆牌上边正面朝上的牌的数目，只要同一数字的牌出现4张正面朝上的牌(比如4个A)，则称“开了一对”，当然4个K是不算的。

6.统计一共开了多少对，开了0对称作”极凶”，1_{2对为“大凶”，3对为“凶”，4}5对为“小凶”，6对为“中庸”，7_{8对“小吉”，9对为“吉”，10}11为“大吉”，12为“满堂开花，极吉”。

输入格式
一共输入13行数据，每行四个数字或字母，表示每堆牌的具体牌型(不区分花色只区分数字)，每堆输入的顺序为从上到下。

为了便于读入，用0代表10。

同行数字用空格隔开。

输出格式
输出一个整数，代表统计得到的开出的总对数。

输入样例：
8 5 A A
K 5 3 2
9 6 0 6
3 4 3 4
3 4 4 5
5 6 7 6
8 7 7 7
9 9 8 8
9 0 0 0
K J J J
Q A Q K
J Q 2 2
A K Q 2
输出样例：
9

思路：搜索+模拟

感觉这道题目，就是一道纯模拟的题目，没有什么难点，大致有几个易错点，这里提醒一下。
每次拿该堆的末尾，这一点容易犯错，因为不是拿之前的第四张牌，而是当前的末尾的牌。
读入问题，这里读入需要特判几个点，也就是A,10,J,Q,K
注意存储问题，我的代码，下标0表示堆顶，5表示堆尾

代码：

#include
#include
using namespace std;

const int N=14;
vector<int> cards[14];//1——13堆每一堆倒扣着牌的数字
int open[14];//正面朝上的牌的个数，只需存1——13堆中每堆的个数，因为第一堆的牌面为1


int get(char c){
   
    if(c=='A') return 1;
    if(c>='2'&&c<='9')return c-'0';
    if(c=='J')return 11;
    if(c=='0')return 10;
    if(c=='Q')return 12;
    return 13;
    
}
int main(){
   
    for(int i=1;i<14;i++){
   
        for(int j=0;j<4;j++){
   
            char s[2];
            cin>>s;
            cards[i].push_back(get(*s));
        }
    }
    
    for(int i=0;i<4;i++){
   
        int t=cards[13][i];
        while(t!=13){
   
            open[t]++;
            int r=cards[t].back();//各堆的最下面的牌面，即给堆队列的队尾
            cards[t].pop_back();
            t=r;
        }
    }
    
    int res=0;
    for(int i=1;i<13;i++)res+=open[i]>=4;//统计1-12各堆的正面朝上的个数
    
    cout<<res<<endl;
    return 0;
}

3、分形

题目：分形，具有以非整数维形式充填空间的形态特征。

通常被定义为“一个粗糙或零碎的几何形状，可以分成数个部分，且每一部分都（至少近似地）是整体缩小后的形状”，即具有自相似的性质。

输入样例：
1
2
3
4
-1

输出样例

思路：模拟+递归

解题思路：
这道题目思维难度不是很大，我们主要是要看清题目的输出格式，其实当n>1的时候，每一个输出，都可以看作成为九宫格。
接着我们可以注意一下每两个XX之间的空格，就可以发现一定的规律。
这道题目可以不用递归做，但是用递归做非常的简便。

#include

using namespace std;

const int N=1010;

char g[N][N];



void dfs(int n){
   
    if(n==1){
   
        g[0][0]='X';
        return;
    }
    
    dfs(n-1);
    
    int len=1;
    for(int i=0;i<n-2;i++) len*=3;//n级图形边长为3^n-1,n-1级图形边长为3^n-2
    
    int sx[4]={
   0,1,2,2},sy[4]={
   2,1,0,2};//右上角，中间，左下角，右下角各n-1级图形起点坐标
    for(int k=0;k<4;k++)//循环4个起点,每个起点循环一个n-1级图形
        for(int i=0;i<len;i++)
            for(int j=0;j<len