P4461 [CQOI2018]九连环（找规律，大数）

最新推荐文章于 2021-09-24 21:01:40 发布
最新推荐文章于 2021-09-24 21:01:40 发布
阅读量442 收藏
点赞数
分类专栏： 规律题（找啊、找啊、找不着啊）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Du_Mingm/article/details/81486059
版权

 

题目背景

九连环是一种源于中国的传统智力游戏。如图所示，九个的圆环套在一把“剑”上，并且互相牵连。游戏的目标是把九个圆环全部从“剑”上卸下。

题目描述

圆环的装卸需要遵守两个规则:

  1. 第一个(最右边) 环任何时候都可以任意装上或卸下

  2. 如果第k 个环没有被卸下，且第k 个环右边的所有环都被卸下，则第k+1个环(第k 个环左边相邻的环) 可以任意装上或卸下

与魔方的千变万化不同，解九连环的最优策略是唯一的。为简单起见，我们以“四连环”为例，演示这一过程。这里用1表示环在“剑”上，0 表示环已经卸下。

初始状态为1111,每步的操作如下:

  1. 1101 (根据规则2,卸下第2 个环)

  2. 1100 (根据规则1,卸下第1 个环)

  3. 0100 (根据规则2,卸下第4 个环)

  4. 0101 (根据规则1,装上第1 个环)

  5. 0111 (根据规则2,装上第2 个环)

  6. 0110 (根据规则1,卸下第1 个环)

  7. 0010 (根据规则2,卸下第3 个环)

  8. 0011 (根据规则1,装上第1 个环)

  9. 0001 (根据规则2,卸下第2 个环)

  10. 0000 (根据规则1,卸下第1 个环)

由此可见，卸下“四连环”至少需要10 步。随着环数增加，需要的步数也会随之增多。例如卸下九连环，就至少需要341步。

请你计算，有n 个环的情况下，按照规则， 全部卸下至少需要多少步。

输入输出格式

输入格式：

 

输入文件第一行，为一个整数m，表示测试点数目。

接下来m行，每行一个整数n。

 

输出格式：

 

输出文件共m行，对应每个测试点的计算结果。

 

输入输出样例

输入样例#1： 复制

3
3
5
9

输出样例#1： 复制

5
21
341

说明

对于10%的数据， 1≤n≤101≤n≤10

对于30%的数据， 1≤n≤301≤n≤30

对于100%的数据， 1≤n≤10^5,1≤m≤101≤n≤105,1≤m≤10

 

找规律，大数，Java写了一个Python写了一个

import java.math.BigInteger;
import java.util.*;
 
import javax.security.auth.callback.LanguageCallback;
 
public class Main{
     
    public static void main(String[] args)
    {
        Scanner cin = new Scanner(System.in);
         
        BigInteger[] a = new BigInteger[5];
        a[0]=BigInteger.ONE;
        a[1]=a[0].add(a[0]);
        int m,n;
        m = cin.nextInt();
         
        for(int i=0;i<m;i++)
        {
            n = cin.nextInt();
            BigInteger x = a[1];
            for(int j=2;j<=n;j++)
            {
                if(j%2!=0)
                    x=x.multiply(a[1]);
                else
                    x=(x.multiply(a[1])).subtract(a[0]);
            }
            System.out.println(x.subtract(a[0]));
        }
         
    }
}
m = int(input())

for i in range(1,m+1):
    n = int(input())
    ans = 1
    for j in range(1,n+1):
        if(j%2):
            ans = ans*2
        else:
            ans = ans*2 - 1
    print(ans-1)

 

另一个通项公式

m = int(input())
for i in range(1,m+1):
    n = int(input())
    ans = 1
    ans = pow(2,n+1)
    if(n%2):
        ans = (ans-1)//3
    else:
        ans = (ans-2)//3
    print(ans)

 

c++的话要套大数板子，暂时还没写

贴一个大佬的大数板子

 

#include<bits/stdc++.h>
using namespace std;
 
//大整数
struct BigInteger
{
    static const int BASE=100000000;//和WIDTH保持一致
    static const int WIDTH=8;//八位一存储,如修改记得修改输出中的%08d
    bool sign;//符号, 0表示负数
    size_t length;
    vector<int> num;//反序存
//构造函数
    BigInteger (long long x = 0) { *this = x; }
    BigInteger (const string& x) { *this = x; }
    BigInteger (const BigInteger& x) { *this = x; }
//剪掉前导0
    void cutLeadingZero()
    {
        while(num.back() == 0 && num.size() != 1) { num.pop_back(); }
    }
//设置数的长度
    void setLength()
    {
        cutLeadingZero();
        int tmp = num.back();
        if(tmp == 0) { length = 1; }
        else
        {
            length = (num.size() - 1) * WIDTH;
            while(tmp > 0) { ++length; tmp /= 10; }
        }
    }
//赋值运算符
    BigInteger& operator = (long long x)
    {
        num.clear();
        if (x >= 0) sign = true;
        else { sign = false; x = -x; }
        do
        {
            num.push_back(x%BASE);
            x/=BASE;
        }while(x>0);
        setLength();
        return *this;
    }
//赋值运算符
    BigInteger& operator = (const string& str)
    {
        num.clear();
        sign = (str[0] != '-');//设置符号
        int x, len=(str.size()-1-(!sign))/WIDTH+1;
        for(int i=0;i<len;i++)
        {
            int End=str.length()-i*WIDTH;
            int start=max((int)(!sign), End-WIDTH);//防止越界
            sscanf(str.substr(start,End-start).c_str(),"%d",&x);
            num.push_back(x);
        }
        setLength();
        return *this;
    }
//赋值运算符
    BigInteger& operator = (const BigInteger& tmp)
    {
        num = tmp.num;
        sign = tmp.sign;
        length = tmp.length;
        return *this;
    }
 
 
//数的位数
    size_t size() const { return length; }
//*10^n 除法中用到
    BigInteger e(size_t n) const
    {
        int tmp = n % WIDTH;
        BigInteger ans;
        ans.length = n + 1;
        n /= WIDTH;
        while (ans.num.size() <= n) ans.num.push_back(0);
        ans.num[n] = 1;
        while (tmp--) ans.num[n] *= 10;
        return ans*(*this);
    }
//绝对值
    BigInteger abs() const
    {
        BigInteger ans(*this);
        ans.sign = true;
        return ans;
    }
//正号
    const BigInteger& operator + () const { return *this; }
// + 运算符
    BigInteger operator + (const BigInteger& b) const
    {
        if (!b.sign) { return *this - (-b); }
        if (!sign) { return b - (-*this); }
        BigInteger ans;
        ans.num.clear();
        for(int i=0,g=0;;i++)
        {
            if(g==0&&i>=num.size()&&i>=b.num.size()) break;
            int x=g;
            if(i<num.size()) x+=num[i];
            if(i<b.num.size()) x+=b.num[i];
            ans.num.push_back(x%BASE);
            g=x/BASE;
        }
        ans.setLength();
        return ans;
    }
//负号
    BigInteger operator - () const
    {
        BigInteger ans(*this);
        if (ans != 0) ans.sign = !ans.sign;
        return ans;
    }
// - 运算符
    BigInteger operator - (const BigInteger& b) const
    {
        if (!b.sign) { return *this + (-b); }
        if (!sign) { return -((-*this) + b); }
        if (*this < b) { return -(b - *this); }
        BigInteger ans;
        ans.num.clear();
        for(int i=0,g=0;;i++)
        {
            if(g==0&&i>=num.size()&&i>=b.num.size()) break;
            int x=g; g=0;
            if(i<num.size()) x+=num[i];
            if(i<b.num.size()) x-=b.num[i];
            if(x<0)
            {
                x+=BASE;g=-1;
            }
            ans.num.push_back(x);
        }
        ans.setLength();
        return ans;
    }
// * 运算符
    BigInteger operator * (const BigInteger& b) const
    {
        int lena = num.size(), lenb = b.num.size();
        vector<long long> ansLL;
        for (int i = 0; i < lena+lenb; i++) ansLL.push_back(0);
        for (int i = 0; i < lena; i++)
        {
            for (int j = 0; j < lenb; j++)
            {
                ansLL[i+j] += (long long)num[i]*(long long)b.num[j];
            }
        }
        while (ansLL.back() == 0 && ansLL.size() != 1) ansLL.pop_back();
        int len = ansLL.size();
        long long g = 0, tmp;
        BigInteger ans;
        ans.sign = (ansLL.size() == 1 && ansLL[0] == 0) || (sign == b.sign);
        ans.num.clear();
        for (int i = 0; i < len; i++)
        {
            tmp = ansLL[i];
            ans.num.push_back((tmp + g)%BASE);
            g = (tmp + g) / BASE;
        }
        if (g > 0) ans.num.push_back(g);
        ans.setLength();
        return ans;
    }
// / 运算符 (大数除小数)
    BigInteger operator / (const long long& b) const
    {
        BigInteger c;
        c.num.clear();
        for(int i=0;i<num.size();i++)
        {
            c.num.push_back(0);
        }
        long long g=0;
        for(int i=num.size()-1;i>=0;i--)
        {
            c.num[i]=(num[i]+g*BASE)/b;
            g=num[i]+g*BASE-c.num[i]*b;
        }
        for(int i=num.size()-1;c.num[i]==0;i--)
        {
            c.num.pop_back();
        }
        return c;
    }
// /运算符 (大数除大数)
    BigInteger operator / (const BigInteger& b) const
    {
 
        BigInteger aa((*this).abs());
        BigInteger bb(b.abs());
        if (aa < bb) return 0;
        char *str = new char[aa.size() + 1];
        memset(str, 0, sizeof(char)*(aa.size()+1));
        BigInteger tmp;
        int lena = aa.length, lenb = bb.length;
        for (int i = 0; i <= lena - lenb; i++)
        {
            tmp = bb.e(lena - lenb - i);
            while (aa >= tmp)
            {
                ++str[i];
                aa = aa - tmp;
            }
            str[i] += '0';
        }
        BigInteger ans(str);
        delete[]str;
        ans.sign = (ans == 0 || sign == b.sign);
        return ans;
    }
// % 运算符 (大数取模小数)
    BigInteger operator % (const long long& b) const
    {
        long long ans=0,lena=num.size();
        for(int i=lena-1;i>=0;i--)
        {
            ans=(ans*BASE+num[i])%b;
        }
        return ans;
    }
// %运算符 (大数取模大数)
    BigInteger operator % (const BigInteger& b) const
    {
        return *this - *this / b * b;
    }
 
    BigInteger& operator ++ () { *this=*this+1;return *this; } // ++ 运算符
    BigInteger& operator -- () { *this=*this-1;return *this; } // -- 运算符
    BigInteger& operator += (const BigInteger& b) { *this=*this+b;return *this; } // += 运算符
    BigInteger& operator -= (const BigInteger& b) { *this=*this-b;return *this; } // -= 运算符
    BigInteger& operator *= (const BigInteger& b) { *this=*this*b;return *this; } // *=运算符
    BigInteger& operator /= (const long long& b)  { *this=*this/b;return *this; } // /=运算符
    BigInteger& operator /= (const BigInteger& b) { *this=*this/b;return *this; } // /= 运算符
    BigInteger& operator %= (const long long& b)  { *this=*this%b;return *this; } // %=运算符
    BigInteger& operator %= (const BigInteger& b) { *this=*this%b;return *this; } // %=运算符
// < 运算符
    bool operator < (const BigInteger& b) const
    {
        if (sign && !b.sign) { return false; }//正负
        else if(!sign && b.sign) { return true; }//负正
        else if(!sign && !b.sign) { return -b < -*this; }//负负
        //正正
        if(num.size()!=b.num.size()) return num.size()<b.num.size();
        for(int i=num.size()-1;i>=0;i--)
            if(num[i]!=b.num[i]) return num[i]<b.num[i];
        return false;
    }
 
    bool operator >  (const BigInteger& b) const { return b<*this; }              // >  运算符
    bool operator <= (const BigInteger& b) const { return !(b<*this); }           // <= 运算符
    bool operator >= (const BigInteger& b) const { return !(*this<b); }           // >= 运算符
    bool operator != (const BigInteger& b) const { return b<*this||*this<b; }     // != 运算符
    bool operator == (const BigInteger& b) const { return !(b<*this)&&!(*this<b); }//==运算符
 
    bool operator || (const BigInteger& b) const { return *this != 0 || b != 0; } // || 运算符
    bool operator && (const BigInteger& b) const { return *this != 0 && b != 0; } // && 运算符
    bool operator !  () { return (bool)(*this == 0); }                            // ！ 运算符
 
    //重载<<使得可以直接输出大数
    friend ostream& operator << (ostream &out,const BigInteger &x)
    {
        if (!x.sign) out<<'-';
        out<<x.num.back();
        for(int i=x.num.size()-2;i>=0;i--)
        {
            char buf[10];
            //如WIDTH和BASR有变化,此处要修改为%0(WIDTH)d
            sprintf(buf,"%08d",x.num[i]);
            for(int j=0;j<strlen(buf);j++) out<<buf[j];
        }
        return out;
    }
    //重载>>使得可以直接输入大数
    friend istream& operator >> (istream &in, BigInteger &x)
    {
        string str;
        in >> str;
        size_t len = str.size();
        int i, start = 0;
        if (str[0] == '-') start = 1;
        if (str[start] == '\0') return in;
        for (int i = start; i < len; i++)
        {
            if (str[i] < '0' || str[i] > '9') return in;
        }
        x.sign = !start;
        x = str.c_str();
        return in;
    }
 
};
 
BigInteger qpow(int b)
{
    BigInteger ans=1,a=2;
    while(b)
    {
        if(b&1)
            ans=(ans*a);
        a=(a*a);
        b/=2;
    }
    return ans;
}
 
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
 
        BigInteger a=1;
        a=qpow(n+1);
 
        if(n%2)
            a=(a-1)/3;
        else
            a=(a-2)/3;
 
        cout<<a<<endl;
    }
    return 0;
}

 

RevolIA
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++九连环解法步骤，欢迎参考
04-05
九连环解法参考 供大家欣赏，增加对九连环的认识 希望对你有帮助！
九连环问题
最新发布
2301_80348313的博客
12-06 632
九连环是一种流传于山西省的传统民间的智力玩具，由九个圆环相连成串，以解开为胜。九连环的九个环，一环扣一环地套在钗上。除了第 1 号环可以随时装上或卸下以外，其它环装上或卸下的条件是：在它的前面仅有紧靠它那一个环在钗上。即：当第 1 ~ i−2 号环都不在钗上，第 i−1 号环在钗上，这时可以装上或卸下第 i 号环。
6760: 九连环（大数）
一只秀逗__的博客
08-07 447
6760: 九连环 http://exam.upc.edu.cn/problem.php?id=6760 时间限制: 1 Sec  内存限制: 128 MB 提交: 582  解决: 92 [提交] [状态] [讨论版] [命题人:admin] 题目描述 九连环是一种源于中国的传统智力游戏。如图所示，九个圆环套在一把“剑”上，并且互相牵连。游戏的目标是把九个圆环从“剑”上卸下。 圆环...
[CQOI2018]九连环
12-09 107
手写压位高精即可通过 #include"cstdio" #include"cstring" #include"iostream" #include"algorithm" using namespace std; const int MAXN=5505; const int siz=9; const int MOD=1e9; int T,n; struct Big{ long ...
九连环 ← 递归
hnjzsyjyj的专栏
09-24 2171
九连环游戏的历史非常悠久，据说起源于战国时期。 九连环由九个相互连接的环组成，这九个环套在一个中空的长形柄中。 九连环的玩法是要将这九个环从柄上解下来。解下所有九个环需要解341步，因此人们需要有耐心。
2021-8-25【PTA】【九连环问题】
eternity_memory的博客
08-25 2298
九连环是一种流传于山西省的传统民间的智力玩具，由九个圆环相连成串，以解开为胜。 九连环的九个环，一环扣一环地套在钗上。除了第 1 号环可以随时装上或卸下以外，其它环装上或卸下的条件是：在它的前面仅有紧靠它那一个环在钗上。即：当第 1 ~ i−2 号环都不在钗上，第 i−1 号环在钗上，这时可以装上或卸下第 i 号环。 输入格式 环数 操作(U表示装上, D表示卸下) 输出格式 装上或卸下九连环的操作步骤 每行显示一步操作，具体格式为： 环号: U或D (U表示装上，D表示卸下) #include<s
营销九连环编程技巧分析.docx
11-16
营销九连环编程技巧分析.docx
jiulianhuan.rar_jiulianhuan_九连环
09-23
这是一个小程序，可以教你怎么解开九连环，用c写的，可以运行。
C++实现九连环的解法 源码
11-22
包含vs2015的源码包，单个exe程序，和单独的cpp文件。仅为了解法，可以只用exe程序。
基于FPGA解决九连环问题
12-08
整个ise工程，veilog语言，利用fpga解决九连环的数学问题，按键进行解环操作，用数码管显示结果。
toj题目
12-12
toj离线版！！！！！！！！！！！
（待补）（递归）九连环问题*
长夜漫漫，无心睡眠
10-24 1465
九连环是一种流传于山西省的传统民间的智力玩具，由九个圆环相连成串，以解开为胜。 九连环的九个环，一环扣一环地套在钗上。除了第 1 号环可以随时装上或卸下以外，其它环装上或卸下的条件是：在它的前面仅有紧靠它那一个环在钗上。即：当第 1 ~ i−2 号环都不在钗上，第 i−1 号环在钗上，这时可以装上或卸下第 i 号环。 输入格式 环数 操作(U表示装上, D表示卸下) 输出格式 ...
九连环问题（Java）
l870358133的博客
10-18 1603
九连环是一种流传于山西省的传统民间的智力玩具，由九个圆环相连成串，以解开为胜。 九连环的九个环，一环扣一环地套在钗上。除了第 1 号环可以随时装上或卸下以外，其它环装上或卸下的条件是：在它的前面仅有紧靠它那一个环在钗上。即：当第 1 ~ i−2 号环都不在钗上，第 i−1 号环在钗上，这时可以装上或卸下第 i 号环。 输入格式 环数 操作(U表示装上, D表示卸下) 输出格式 ...
bzoj5300: [Cqoi2018]九连环【FFT+高精度】
cdsszjj的博客
05-04 397
传送门 解题思路： 容易发现fi=fi−1+2fi−2+1=2fi−1+(i%2)fi=fi−1+2fi−2+1=2fi−1+(i%2)f_i=f_{i-1}+2f_{i-2}+1=2f_{i-1}+(i\%2)，但还不够。 又发现fi=⌊2i+13⌋fi=⌊2i+13⌋f_i=\lfloor\frac{2^{i+1}}{3}\rfloor，直接FFT+高精度即可。 #include&...
九连环的递归算法（C和C++）
热门推荐
铭毅天下Elasticsearch
08-12 1万+
九连环的递归算法（C和C++） 九连环的递归算法 一、九连环简介 九连环游戏是中国人自己发明的，它的历史非常悠久，据说是起源于战国时期。九连环主要是由一个框架和九个圆环组成：每个圆环上连有一个直杆，而这个直杆则在后面一个圆环内穿过，九个直杆的另一端用一块木板或圆环相对固定。 二、九连环的规律 通过玩九连环你就会发现存在这样一个规律： （1）第 1环可以自由上下 （2）而上/下第 n环
小李打怪兽——01背包
这里RevolIA，_(:з」∠)_
03-02 2011
题目描述 小李对故乡的思念全部化作了对雾霾天气的怨念，这引起了掌控雾霾的邪神的极大不满，邪神派去了一只小怪兽去对付小李，由于这只怪兽拥有极高的IQ，它觉得直接消灭小李太没有难度了，它决定要和小李在智力水平上一较高下。我们可否帮助小李来战胜强大的怪兽呢？ 问题是这样的：给定一堆正整数，要求你分成两堆，两堆数的和分别为S1和S2，谁分的方案使得S1*S1-S2*S2的结果小（规定S1&gt;=S2）...
ACM-ICPC 2018 南京赛区网络预赛-J_sum
这里RevolIA，_(:з」∠)_
09-01 1967
A square-free integer is an integer which is indivisible by any square number except 11. For example, 6 = 2 \cdot 36=2⋅3 is square-free, but 12 = 2^2 \cdot 312=22⋅3 is not, because 2^222 is a square n...
buuctf 九连环 1
07-16
九连环是其中的一道题目。 九连环是一个由九个环组成的智力游戏，目标是通过一系列的操作，将环从上到下按照一定的规则进行排列。这道题目可能要求我们编写一个程序来解决九连环的排列问题。 我们可以采用深度优先...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值