uva 10862 uva 10334 uva 10359 uva 10918 （大数+递推）

最新推荐文章于 2021-02-15 23:41:08 发布
最新推荐文章于 2021-02-15 23:41:08 发布
阅读量514 收藏
点赞数
分类专栏： 数论数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013508213/article/details/42691461
版权

10334是fib，不说了。


10862：

题意：

给n个房子，让他们和一个信号站连，求连法。


解析：

设f[n]代表n个房子的连法。

             O

房子堆n-1  房子n

到达当前决策n时，房子n可以连圈，则此时连法是f[n -1]，可以连房子堆n-1，连法也是f[n - 1]。

还有一种连法就是房子n与房子n-1，圈圈O都相连，此时影响到前面的决策，即房子n-2不能与O相连，则连法f[n -1 ] - f[n - 2]。

和：3 * f[n-1] - f[n-2]


代码：


#include <cstdio>
#include <iostream>
#include <cstring>
#include <climits>
#include <cassert>
using namespace std;

#define maxn 30000

struct bign
{
    long long len, s[maxn];

    bign()
    {
        memset(s, 0, sizeof(s));
        len = 1;
    }

    bign(long long num)
    {
        *this = num;
    }

    bign(const char* num)
    {
        *this = num;
    }

    bign operator = (long long num)
    {
        char s[maxn];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }

    bign operator = (const char* num)
    {
        len = strlen(num);
        for (long long i = 0; i < len; i++) s[i] = num[len-i-1] - '0';
        return *this;
    }

    string str() const
    {
        string res = "";
        for (long long i = 0; i < len; i++) res = (char)(s[i] + '0') + res;
        if (res == "") res = "0";
        return res;
    }

    /*去除前导0*/
    void clean()
    {
        while(len > 1 && !s[len-1]) len--;
    }

    /*高精度的加法*/
    bign operator + (const bign& b) const
    {
        bign c;
        c.len = 0;
        for (long long i = 0, g = 0; g || i < max(len, b.len); i++)
        {
            long long x = g;
            if (i < len) x += s[i];
            if (i < b.len) x += b.s[i];
            c.s[c.len++] = x % 10;
            g = x / 10;
        }
        return c;
    }

    /*高精度的减法*/
    bign operator - (const bign& b)
    {
        bign c;
        c.len = 0;
        for (long long i = 0, g = 0; i < len; i++)
        {
            long long x = s[i] - g;
            if (i < b.len) x -= b.s[i];
            if (x >= 0)
                g = 0;
            else
            {
                g = 1;
                x += 10;
            }
            c.s[c.len++] = x;
        }
        c.clean();
        return c;
    }

    /*高精度的乘法*/
    bign operator * (const bign& b)
    {
        bign c;
        c.len = len + b.len;
        for (long long i = 0; i < len; i++)
            for (long long j = 0; j < b.len; j++)
                c.s[i+j] += s[i] * b.s[j];
        for (long long i = 0; i < c.len-1; i++)
        {
            c.s[i+1] += c.s[i] / 10;
            c.s[i] %= 10;
        }
        c.clean();
        return c;
    }

    /*高精度除以低精度*/    /*用到除法和取余的时候可能需要把全局的int替换成long long*/
    bign operator / (long long b) const
    {
        assert(b > 0);
        bign c;
        c.len = len;
        for (long long i = len-1, g = 0; i >= 0; --i)
        {
            long long x = 10*g+s[i];    //这里可能会超过int 故用long long

            c.s[i] = x/b;                //这里可能会超过int

            g = x-c.s[i]*b;                //这里可能会超过int
        }
        c.clean();
        return c;
    }

    /*高精度对低精度取余*/    /*用到除法和取余的时候可能需要把全局的int替换成long long*/
    bign operator % (long long b)
    {
        assert(b > 0);
        bign d = b;
        bign c = *this-*this/b*d;
        return c;
    }

    bool operator < (const bign& b) const
    {
        if (len != b.len) return len < b.len;
        for (long long i = len-1; i >= 0; i--)
            if (s[i] != b.s[i]) return s[i] < b.s[i];
        return false;
    }

    bool operator > (const bign& b) const
    {
        return b < *this;
    }

    bool operator <= (const bign& b)
    {
        return !(b > *this);
    }

    bool operator >= (const bign& b)
    {
        return !(b < *this);
    }

    bool operator == (const bign& b)
    {
        return !(b < *this) && !(*this < b);
    }

    bool operator != (const bign& b)
    {
        return (b < *this) || (*this < b);
    }

    bign operator += (const bign& b)
    {
        *this = *this + b;
        return *this;
    }
};

istream& operator >> (istream &in, bign& x)
{
    string s;
    in >> s;
    x = s.c_str();
    return in;
}

ostream& operator << (ostream &out, const bign& x)
{
    out << x.str();
    return out;
}

bign f[2000 + 10];
void init()
{
    f[1] = 1, f[2] = 3;
    bign three = 3;
    for (int i = 3; i <= 2000; i++)
        f[i] = three * f[i - 1] - f[i - 2];
}

int main()
{
#ifdef LOCAL
    freopen("in.txt", "r" , stdin);
#endif
    init();
    int n;
    while (cin >> n && n)
        cout << f[n] << endl;
}


10359：

题意：

用1*1和1*2的瓷砖，问能贴几个n*2的方格。


解析：

当前格，加1格得到：f（n-1）种方法，加2格得到：2 * f（n-2）种方法。

0的时候输出1，。。。。。。。。。。。。。。。。。


代码：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <climits>
#include <cassert>
using namespace std;

#define maxn 30000

struct bign
{
    long long len, s[maxn];

    bign()
    {
        memset(s, 0, sizeof(s));
        len = 1;
    }

    bign(long long num)
    {
        *this = num;
    }

    bign(const char* num)
    {
        *this = num;
    }

    bign operator = (long long num)
    {
        char s[maxn];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }

    bign operator = (const char* num)
    {
        len = strlen(num);
        for (long long i = 0; i < len; i++) s[i] = num[len-i-1] - '0';
        return *this;
    }

    string str() const
    {
        string res = "";
        for (long long i = 0; i < len; i++) res = (char)(s[i] + '0') + res;
        if (res == "") res = "0";
        return res;
    }

    /*去除前导0*/
    void clean()
    {
        while(len > 1 && !s[len-1]) len--;
    }

    /*高精度的加法*/
    bign operator + (const bign& b) const
    {
        bign c;
        c.len = 0;
        for (long long i = 0, g = 0; g || i < max(len, b.len); i++)
        {
            long long x = g;
            if (i < len) x += s[i];
            if (i < b.len) x += b.s[i];
            c.s[c.len++] = x % 10;
            g = x / 10;
        }
        return c;
    }

    /*高精度的减法*/
    bign operator - (const bign& b)
    {
        bign c;
        c.len = 0;
        for (long long i = 0, g = 0; i < len; i++)
        {
            long long x = s[i] - g;
            if (i < b.len) x -= b.s[i];
            if (x >= 0)
                g = 0;
            else
            {
                g = 1;
                x += 10;
            }
            c.s[c.len++] = x;
        }
        c.clean();
        return c;
    }

    /*高精度的乘法*/
    bign operator * (const bign& b)
    {
        bign c;
        c.len = len + b.len;
        for (long long i = 0; i < len; i++)
            for (long long j = 0; j < b.len; j++)
                c.s[i+j] += s[i] * b.s[j];
        for (long long i = 0; i < c.len-1; i++)
        {
            c.s[i+1] += c.s[i] / 10;
            c.s[i] %= 10;
        }
        c.clean();
        return c;
    }

    /*高精度除以低精度*/    /*用到除法和取余的时候可能需要把全局的int替换成long long*/
    bign operator / (long long b) const
    {
        assert(b > 0);
        bign c;
        c.len = len;
        for (long long i = len-1, g = 0; i >= 0; --i)
        {
            long long x = 10*g+s[i];    //这里可能会超过int 故用long long

            c.s[i] = x/b;                //这里可能会超过int

            g = x-c.s[i]*b;                //这里可能会超过int
        }
        c.clean();
        return c;
    }

    /*高精度对低精度取余*/    /*用到除法和取余的时候可能需要把全局的int替换成long long*/
    bign operator % (long long b)
    {
        assert(b > 0);
        bign d = b;
        bign c = *this-*this/b*d;
        return c;
    }

    bool operator < (const bign& b) const
    {
        if (len != b.len) return len < b.len;
        for (long long i = len-1; i >= 0; i--)
            if (s[i] != b.s[i]) return s[i] < b.s[i];
        return false;
    }

    bool operator > (const bign& b) const
    {
        return b < *this;
    }

    bool operator <= (const bign& b)
    {
        return !(b > *this);
    }

    bool operator >= (const bign& b)
    {
        return !(b < *this);
    }

    bool operator == (const bign& b)
    {
        return !(b < *this) && !(*this < b);
    }

    bool operator != (const bign& b)
    {
        return (b < *this) || (*this < b);
    }

    bign operator += (const bign& b)
    {
        *this = *this + b;
        return *this;
    }
};

istream& operator >> (istream &in, bign& x)
{
    string s;
    in >> s;
    x = s.c_str();
    return in;
}

ostream& operator << (ostream &out, const bign& x)
{
    out << x.str();
    return out;
}

bign f[250 + 10];
void init()
{
    f[0] = 1;
    f[1] = 1, f[2] = 3;
    bign two = 2;
    for (int i = 3; i <= 250; i++)
        f[i] = two * f[i - 2] + f[i - 1];
}

int main()
{
#ifdef LOCAL
    freopen("in.txt", "r" , stdin);
#endif
    init();
    int n;
    while (cin >> n)
        cout << f[n] << endl;
}


10918：

题意：

给n，求用1*2的瓷砖有多少种方法能谱n*3的矩形。


解析：

奇数无解，当前选择，由n-2的瓷砖得来，有3 * f（n-2）种方法，若由n-4的瓷砖得来（f（n-2） - f（n-4））种方法。


代码：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <climits>
#include <cassert>
using namespace std;

#define maxn 30000

struct bign
{
    long long len, s[maxn];

    bign()
    {
        memset(s, 0, sizeof(s));
        len = 1;
    }

    bign(long long num)
    {
        *this = num;
    }

    bign(const char* num)
    {
        *this = num;
    }

    bign operator = (long long num)
    {
        char s[maxn];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }

    bign operator = (const char* num)
    {
        len = strlen(num);
        for (long long i = 0; i < len; i++) s[i] = num[len-i-1] - '0';
        return *this;
    }

    string str() const
    {
        string res = "";
        for (long long i = 0; i < len; i++) res = (char)(s[i] + '0') + res;
        if (res == "") res = "0";
        return res;
    }

    /*去除前导0*/
    void clean()
    {
        while(len > 1 && !s[len-1]) len--;
    }

    /*高精度的加法*/
    bign operator + (const bign& b) const
    {
        bign c;
        c.len = 0;
        for (long long i = 0, g = 0; g || i < max(len, b.len); i++)
        {
            long long x = g;
            if (i < len) x += s[i];
            if (i < b.len) x += b.s[i];
            c.s[c.len++] = x % 10;
            g = x / 10;
        }
        return c;
    }

    /*高精度的减法*/
    bign operator - (const bign& b)
    {
        bign c;
        c.len = 0;
        for (long long i = 0, g = 0; i < len; i++)
        {
            long long x = s[i] - g;
            if (i < b.len) x -= b.s[i];
            if (x >= 0)
                g = 0;
            else
            {
                g = 1;
                x += 10;
            }
            c.s[c.len++] = x;
        }
        c.clean();
        return c;
    }

    /*高精度的乘法*/
    bign operator * (const bign& b)
    {
        bign c;
        c.len = len + b.len;
        for (long long i = 0; i < len; i++)
            for (long long j = 0; j < b.len; j++)
                c.s[i+j] += s[i] * b.s[j];
        for (long long i = 0; i < c.len-1; i++)
        {
            c.s[i+1] += c.s[i] / 10;
            c.s[i] %= 10;
        }
        c.clean();
        return c;
    }

    /*高精度除以低精度*/    /*用到除法和取余的时候可能需要把全局的int替换成long long*/
    bign operator / (long long b) const
    {
        assert(b > 0);
        bign c;
        c.len = len;
        for (long long i = len-1, g = 0; i >= 0; --i)
        {
            long long x = 10*g+s[i];    //这里可能会超过int 故用long long

            c.s[i] = x/b;                //这里可能会超过int

            g = x-c.s[i]*b;                //这里可能会超过int
        }
        c.clean();
        return c;
    }

    /*高精度对低精度取余*/    /*用到除法和取余的时候可能需要把全局的int替换成long long*/
    bign operator % (long long b)
    {
        assert(b > 0);
        bign d = b;
        bign c = *this-*this/b*d;
        return c;
    }

    bool operator < (const bign& b) const
    {
        if (len != b.len) return len < b.len;
        for (long long i = len-1; i >= 0; i--)
            if (s[i] != b.s[i]) return s[i] < b.s[i];
        return false;
    }

    bool operator > (const bign& b) const
    {
        return b < *this;
    }

    bool operator <= (const bign& b)
    {
        return !(b > *this);
    }

    bool operator >= (const bign& b)
    {
        return !(b < *this);
    }

    bool operator == (const bign& b)
    {
        return !(b < *this) && !(*this < b);
    }

    bool operator != (const bign& b)
    {
        return (b < *this) || (*this < b);
    }

    bign operator += (const bign& b)
    {
        *this = *this + b;
        return *this;
    }
};

istream& operator >> (istream &in, bign& x)
{
    string s;
    in >> s;
    x = s.c_str();
    return in;
}

ostream& operator << (ostream &out, const bign& x)
{
    out << x.str();
    return out;
}

bign f[30 + 10];
void init()
{
    f[0] = 1;
    f[2] = 3;
    bign four = 4;
    for (int i = 4; i <= 30; i++)
        f[i] = four * f[i - 2] - f[i - 4];
}

int main()
{
#ifdef LOCAL
    freopen("in.txt", "r" , stdin);
#endif
    init();
    int n;
    while (cin >> n && n != -1)
        cout << f[n] << endl;
}


AlmostFree
关注
专栏目录
递推计数问题题目总结
taotao 的大学墓志
03-27 2235
introduction主要总结一些常用的递推计数技巧和题目.包括格点计数.树堆排列数目.分类技巧分类是处理计数问题的重要计数.一定要注意不重不漏.并且常对包含某一个元素的特定情况进行计数，然后在全部加起来.UVA 11038 - How Many O’s? 枚举法，限定每个0的位置分类计数.UVA 10883 - Supermean 找规律，注意大数相除取对数技巧codeforce 785D———
uva 10328 - Coin Toss(计数问题）
不慌不忙、不急不躁
11-04 4749
题目链接：uva 10328 - Coin Toss 题目大意：给出n，表示有投掷n次硬币，硬币有分正反面，玩游戏的人比较迷信，如果他选择正面获胜的话，第二次他还是会选正面（不知道这句话要说什么，应该是背景），然后给出k，问说出现连续正面的此处大于 等于k的情况有多少种，比如说：3 2，投掷3次或有8中情况，满足说有两个以上连续的'H'（正面）的情况只有“HHH”， “HHT”， “TH
UVA10862 - Connect the Cable Wires（递推 + java的大数）
diandingyin9417的博客
06-28 103
UVA10862 - Connect the Cable Wires（递推 + java的大数） 题目链接 题目大意：给你n座房子位于一条直线上，然后仅仅给你一个cable service。要求每座房子都连上有线，方式能够是间接的通过这个房子的直接邻居连接（前提是它的邻居要连上有线），第二种是直接连上cable service也是能够的。 解题思路：把后面的...
UVa 10359 - Tiling
小白菜又菜
04-17 1234
题目：给你一个2*n的地面，用1*2和2*2的地板砖铺满，有多少种不同方案。 分析：组合数学，动态规划。直接找到地推关系求解。             因为，只可能是最后一列是一个整体（1种情况）或者最后两列是一个整体（两种情况）；             所以，有递推公式：f（n）= f（n-1）+ 2*f（n-2）；             可以使用动态规划或母函数（an = （pow
UVA 10862 - Connect the Cable Wires(数论 递推 高精度）
Remilia's
11-12 1228
Input: Standard In Output: Standard Out Next Generation Contest 1  Time Limit: 1 second Problem G Connect the Cable Wires  Asif is a student of East Wes
UVa:10862 Connect the Cable Wires（斐波那契数列大数）
Fighting
03-18 642
输出斐波那契数列的第2*n项即可。需要用大数。
UVA10862 Connect the Cable Wires【大数+递推】
海岛Blog
05-06 500
Asif is a student of East West University and he is currently working for the EWUISP to meet his relatively high tuition fees. One day, as a part of his job, he was instructed to connect cable wires t...
小学期acm训练第一发(简单数学题)
萌萌哒黑大帅的博客
07-21 1006
这一部分为刘汝佳的《算法竞赛入门经典》（第一版）第三章的数学杂题部分，知识点的确比较杂，但还是以模拟为主。 题目链接：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=43038#overview 题目分析： A.让你对一个高精度的数求开方，直接开高精模板好像会T，所以使用了JAVA（JAVA自带快速幂，所以算乘方的时候回比较快），在
ACM题题题 经典题+分类 我真的还想什么都不想只搞ACM就好了~~~
神思love
06-18 617
1
《组合数学全家桶》（ACM / OI 全网最全，清晰易懂）
繁凡さん的博客
02-15 1万+
组合数学合集（ACM / OI 全网最全，清晰易懂）《组合数学全家桶》
uva 10862 - Connect the Cable Wires(规律）
不慌不忙、不急不躁
11-02 1441
题目连接：uva 10862 - Connect the Cable Wires 递推公式：c[i] = 3 * c[i - 1] - c[i - 2],大数，直接拷模板了。 #include #include #include using namespace std; const int N = 1005; const int M = 2005; struct b
uva 10359 Tiling
@fei
03-12 311
uva 10359 Tiling
poj 1222 高斯消元详解
渐近自由
08-03 4399
题意 有一个5 * 6的矩阵，每个位置表示灯，1表示灯亮，0表示灯灭。 然后如果选定位置i，j点击，则位置i，j和其上下左右的灯的状态都会反转。 现在要你求出一个5 * 6的矩阵，1表示这个灯被点击过，0表示没有。 要求这个矩阵能够使得原矩阵的灯全灭。 非诚勿扰。 解析 来源 首先，要明确一些问题： 1.这些灯点击的顺序可以是任意的； 2.每只灯只能被点击1次，因为点击2次相当
poj 3641 快速幂+米勒罗宾判断大素数
渐近自由
07-21 1665
题意： 判断一个数p是否满足： 1.p不是素数； 2.pow_mod(a, p, p) == a % p。 代码： #include #include #include #include #include #include #include #include #include #include #include #include #define LL lo
数论入门整理（updating）
渐近自由
02-09 1212
一、gcd lcm 基础中的基础，一般用来处理计算第一步什么的，分数化简之类。 LL gcd(LL a, LL b) { return b ? gcd(b, a % b) : a; } 例题：hrbust 1178 hdu 2028 Lowest Common Multiple Plus 二、exgcd 例题：poj 1061 + poj 2115
uva 113 Power of Cryptography（开方）
渐近自由
07-03 877
题意是求出 k ^ n = p。 给p和n，求k
sg函数入门题
渐近自由
07-24 785
poj 2311： 题意： 给一个 w * h 的矩形纸片，每次可以剪一刀，谁先剪到1 * 1谁就赢。 解析： 用sg函数来找必胜态和必败态，然后类似记忆化搜索，不断往下找。 代码： #include #include #include #include #include #include #include #include #include #inc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值