蓝桥杯机器人塔——python

题目如下：

X 星球的机器人表演拉拉队有两种服装，A 和 B。

他们这次表演的是搭机器人塔。

类似：

A

B B

A B A

A A B B

B B B A B

A B A B B A

队内的组塔规则是：

A 只能站在 AA 或 BB 的肩上。

B 只能站在 AB 或 BA 的肩上。

你的任务是帮助拉拉队计算一下，在给定 A 与 B 的人数时，可以组成多少种花样的塔。

输入描述
输入一行两个整数 M,NM,N（0

输出描述
要求输出一个整数，表示可以产生的花样种数。

输入输出样例
示例
输入

1 2
输出

3

题目解析

这道题该怎么做那？我们实际上发现只需要查明白第一行就可以直接往上推了。就不用议论之这么多了。但是第一行应该有多少个呐？机器人总数 cnt = M+N，那么可以做多少层？可以这样思考，假设有 num 层，这就是长度为 num 步长为 1 的等差数列，那么塔内机器人总数 cnt = num*(num+1)/2 = M+N，所以 num = sqrt((M + N) * 2)。所以我们就定下来了，接下来就是来寻找第一行了，然后再查看是否可以向上扩展，A，B的数目是否足够使用。
在这里遍历所有第一行的选项，我们使用递归的方式，同时用1表示A，2表示B。
然后设置一个检查代码，从而行开始计算所有的A，B，个数如果到了顶层还是和m,n相同，说明是可行的。

code

import math

def check():# 判断是否可以向上拓展
    a = 0
    b = 0
    tmp = row
    while tmp >0:
        for i in range(1, tmp+1):
            if cnt[i] == 1:
                a +=1
            else:
                b += 1
        for i in range(2, tmp+1):
            if cnt[i-1]==cnt[i]:
                cnt[i-1] = 1
            else:
                cnt[i-1] = 2
        tmp -=1
    if a == m and b == n:
        return True
    else:
        return False

def dfs(k):# 遍历所有第一排
    global res
    if k > row:
        if check():
            res +=1
        return
    cnt[k] = 1
    dfs(k+1)
    cnt[k] = 2
    dfs(k+1)

if __name__ == "__main__":
    m = int(input())
    n = int(input())
    res = 0
    cnt = [0 for _ in range(100010)]
    row = int(math.sqrt(2*(m+n)))
    dfs(1)
    print(res)

第二种解法

当然除了这一种我还查询了别的，因为这种实在不是太快，我在网上搜集了另外一种，其实原理也是差不多，增大了代码量使得时间复杂度降低一点，同时可以容纳更多的数据。代码如下

def dfs(x, s, aa,bb):
    global ans
    if aa<0 or bb<0:
        return
    if aa==0 or bb==0:
        ans +=1
        return
    cs = bs = 0
    p = 'A'
    cs +=1
    for i in range(len(s)):
        if s[i] == 'A':
            if p[i] =='A':
                p += 'A'
                cs += 1
            else:
                p+= 'B'
                bs +=1
        else:
            if p[i] =='A':
                p += 'B'
                bs += 1
            else:
                p+= 'A'
                cs +=1
    dfs(x+1, p, aa-cs, bb-bs)
    cs = bs = 0
    q = 'B'
    bs +=1
    for i in range(len(s)):
        if s[i] == 'A':
            if q[i] =='A':
                q += 'A'
                cs += 1
            else:
                q+= 'B'
                bs +=1
        else:
            if q[i] =='A':
                q += 'B'
                bs += 1
            else:
                q+= 'A'
                cs +=1
    dfs(x+1, q, aa-cs, bb-bs)


if __name__ == "__main__":
    a = int(input())
    b = int(input())
    ans = 0
    c = []
    c += 'A'
    dfs(1,c,a-1,b)
    c[0] = 'B'
    dfs(1,c,a, b-1)
    print(ans)

第三种解法

第三种解法应该是最为简单的，但是很遗憾，源码是C语言的，我在尝试用python写的时候却发现python的位运算有极大的缺点，在算较大的数字是会无法转换更长的整型而导致发生了变成负数，这个报错我找了好久没有找到，只能咬牙切齿，也明白了在享受便利的时候也会招来麻烦。
这种方法是利用二进制的位运算，原理如下

'''
若把 A 看成 0，把 B 看成 1，则异或运算可以很好的算出两个机器人上面的机器人类型。

AB 排列，视为 01 串，其整数值为 x，那么其上层 AB-01 串的整数值 y 的计算公式：
y =  x ^ (x右移一位)然后去掉最高位
举例来说：

A B A B B A 转为二进制是 x = 010110，相邻位从左到右异或等价于 x^(x>>1) 结果为 y=011101，y 的高位无意义应去掉，最终结果为 y=11101 即 BBBAB，因此计算 y 值的伪代码是：
y = x ^ (x>>1)

y &= (1 << (i - 1))  - 1 // 等号右边的式子可以把最高位右侧全部置为1
这样就变成了一个高效的迭代算法。
'''
# 代码如下，汇报错误
# 二进制
import math


n = 1
m = 2
num = int(math.sqrt((m+n)*2))
ans = 0

def nbit(x):
    ans = 0

    while x:
        x = x&(x-1)
        ans +=1
    return ans

def check(i, num):
    a = 0
    b = 0

    for j in range(num, 1, -1):
        count = nbit(i)
        a +=count
        b+=i-count
        i = i^(i>>1)
        s = 1 << (i-1)-1
        i = i & s
        if a>m or b > n:
            return False
    return a == m and b == n

for i in range(1<<num):
    if check(i, num):
        ans +=1
print(ans)

但是C++的代码可以很好的运行，所以可以尝试一下。

#include
#include
#include

using namespace std;


int n, m;
int nbit(int num) {
     
    int ans = 0;
    while(num){
     
        num = (num-1) & num;
        ans++;
    }
    return ans;
}
bool check(int now, int floor) {
     
    int num_a = 0, num_b = 0;

    for (int i = floor; i >= 1; i--) {
     //i是层数，也是机器人个数
        int count1 = nbit(now);//now里面有多少1
        num_b += count1;
        num_a += i - count1;//now里面有多少0
        //下面开始求上一层的now
        now ^= now >> 1;
        now &= (1 << (i - 1)) - 1; // 消掉高位

        if (num_a > m || num_b >> n) return false;// 可以提升一点性能
    }
    return num_a == m && num_b == n;
}

int main() {
     
//    freopen("/Users/zhengwei/CLionProjects/lq_final/2016_c_b/4/in6.txt", "r", stdin);
    cin >> m >> n;
    //利用double转int类型向下取整得性质，由(floor + 1) * (floor) / 2 == n + m 推导得
    int floor = sqrt((n + m) * 2);//底行人数==层数

    int ans = 0;
    //2的floor次方种排列方案，每一种方案表示为i
    for (int i = 0; i < (1 << floor); i++) {
     
        if (check(i, floor))
            ans++;
    }
    cout << ans << endl;
}

总结

能看到这的人一定很厉害吧，这道题是第六题，对于一共七题的蓝桥杯已经算是压轴题了，的确这道题很难完全做出来，也就只能想出来简单的dfs算法，只能通过部分数据，但是我觉得这些部分数据已经足够我们来超过许多选手，题目难不要放弃，但是也不要一直耗时间。学会”做题“不只是学会做题。大家加油。