麻将游戏题解

最新推荐文章于 2024-08-30 16:00:44 发布
最新推荐文章于 2024-08-30 16:00:44 发布
阅读量157 收藏
点赞数 1
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50061740/article/details/112741265
版权

高精度模板

前言

支持复数，有a+b,a-b,a*b,a/b,a%b,快速幕
本人码风

代码

#include<iostream>
#include<cstdio>
#include<cstring>

using namespace std;

typedef long long ll;

const int maxn = 10000;
const int BIT = 4;
const int MOD = 1e4;

struct bign {
    int num[maxn], len;
    bool flag;

    friend bign abs(const bign &x) {
        bign k = x;
        k.flag = true;
        return k;
    }

    friend void remove(bign &x) {
        while (x.num[x.len] == 0 && x.len > 1)x.len--;
    }

    bign() {
        memset(num, 0, sizeof(num));
        flag = true;
        len = 1;
    }

    bign(const int &x) {
        *this = bign();
        if (x) {
            int k = x;
            if (k < 0)k = -k, flag = false;
            len = 0;
            while (k) {
                num[++len] = k % MOD;
                k /= MOD;
            }
        }
    }

    bign(const ll &x) {
        *this = bign();
        if (x) {
            ll k = x;
            if (k < 0)k = -k, flag = false;
            len = 0;
            while (k) {
                num[++len] = k % MOD;
                k /= MOD;
            }
        }
    }

    bign(const char *x) {
        int l = strlen(x), s, t = 0, p = 0, k = 1;
        *this = bign();
        if (x[0] == '-')flag = false, s = 1;
        len = 0;
        for (int i = l - 1; i >= s; i--) {
            p += k * (x[i] - '0');
            k *= 10;
            t++;
            if (t == 4) {
                t = 0;
                num[++len] = p;
                p = 0;
                k = 1;
            }
        }
        if (p)num[++len] = p;
    }

    bign(const string x) {
        int l = x.length(), s = 0, t = 0, p = 0, k = 1;
        *this = bign();
        if (x[0] == '-')flag = false, s = 1;
        len = 0;
        for (int i = l - 1; i >= s; i--) {
            p += k * (x[i] - '0');
            k *= 10;
            t++;
            if (t == BIT) {
                t = 0;
                num[++len] = p;
                p = 0;
                k = 1;
            }
        }
        if (p)num[++len] = p;
    }

    bign operator=(const int &x) {
        return *this = bign(x);
    }

    bign operator=(const ll &x) {
        return *this = bign(x);
    }

    bign operator=(const char *x) {
        return *this = bign(x);
    }

    bign operator=(const string &x) {
        return *this = bign(x);
    }

    bool operator<(const bign &x) const {
        if (flag != x.flag)return flag < x.flag;
        if (len != x.len)return (len < x.len) ^ flag ^ 1;
        for (int i = len; i >= 1; i--) {
            if (num[i] != x.num[i]) {
                return (num[i] < x.num[i]) ^ flag ^ 1;
            }
        }
        return false;
    }

    bool operator<(const int &x) const {
        return *this < bign(x);
    }

    bool operator<(const ll &x) const {
        return *this < bign(x);
    }

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

    bool operator>(const int &x) const {
        return *this > bign(x);
    }

    bool operator>(const ll &x) const {
        return *this > bign(x);
    }

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

    bool operator<=(const int &x) const {
        return *this <= bign(x);
    }

    bool operator<=(const ll &x) const {
        return *this <= bign(x);
    }

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

    bool operator>=(const int &x) const {
        return *this >= bign(x);
    }

    bool operator>=(const ll &x) const {
        return *this >= bign(x);
    }

    bool operator==(const bign &x) const {
        if (flag != x.flag)return false;
        if (len != x.len)return false;
        for (int i = len; i >= 1; i--) {
            if (num[i] != x.num[i]) {
                return false;
            }
        }
        return true;
    }

    bool operator==(const int &x) const {
        return *this == bign(x);
    }

    bool operator==(const ll &x) const {
        return *this == bign(x);
    }

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

    bool operator!=(const int &x) const {
        return *this != bign(x);
    }

    bool operator!=(const ll &x) const {
        return *this != bign(x);
    }

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

    friend ostream &operator<<(ostream &out, const bign &x) {
        if (x.flag == false && x != 0)out << "-";
        out << x.num[x.len];
        for (int i = x.len - 1; i >= 1; i--)printf("%0*d", BIT, x.num[i]);
        return out;
    }

    bign operator-() const {
        bign k = *this;
        k.flag ^= 1;
        return k;
    }

    bign operator+(const bign &x) const {
        if (flag && x.flag) {
            bign k = bign();
            k.len = 0;
            for (int i = 1, g = 0; g || i <= len || i <= x.len; i++) {
                int p = num[i] + x.num[i] + g;
                k.num[++k.len] = p % MOD;
                g = p / MOD;
            }
            return k;
        }
        if (flag && !x.flag)return *this - (-x);
        if (!flag && x.flag)return x - (-*this);
        return -((-x) + (-*this));
    }

    bign operator+(const int &x) const {
        return *this + bign(x);
    }

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

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

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

    bign operator++() {
        return *this += 1;
    }

    bign operator++(int) {
        bign k = *this;
        *this += 1;
        return k;
    }

    bign operator-(const bign &x) const {
        if (flag && x.flag && *this >= x) {
            bign k = bign();
            k.len = 0;
            for (int i = 1, g = 0; g || i <= len; i++) {
                int p = num[i] - x.num[i] + g;
                if (p < 0)g = -1;
                else g = 0;
                k.num[++k.len] = (p % MOD + MOD) % MOD;
            }
            remove(k);
            return k;
        }
        if (flag && x.flag)return -(x - *this);
        if (flag && !x.flag)return *this + (-x);
        if (!flag && x.flag)return -((-*this) + x);
        return (-x) - (-*this);
    }

    bign operator-=(const bign &x) {
        *this = *this - x;
        return *this;
    }

    bign operator-=(const int &x) {
        return *this -= bign(x);
    }

    bign operator-=(const ll &x) {
        return *this -= bign(x);
    }

    bign operator--() {
        return *this -= 1;
    }

    bign operator--(int) {
        bign k = *this;
        *this -= 1;
        return k;
    }

    bign operator*(const bign &x) const {
        bign k;
        k.flag = (flag == x.flag);
        k.len = len + x.len + 1;
        for (int i = 1; i <= len; i++) {
            for (int j = 1; j <= x.len; j++) {
                k.num[i + j - 1] += num[i] * x.num[j];
                k.num[i + j] += k.num[i + j - 1] / MOD;
                k.num[i + j - 1] %= MOD;
            }
        }
        remove(k);
        return k;
    }

    bign operator*(const int &x) const {
        bign k = bign();
        k.len = 0;
        long long t[maxn];
        memset(t, 0, sizeof(t));
        for (int i = 1; i <= len; i++)t[i] = num[i] * x;
        for (int i = 1, g = 0; i <= len || g; i++) {
            k.num[++k.len] = (g + t[i]) % MOD;
            g = (g + t[i]) / MOD;
        }
        return k;
    }

    bign operator*(const ll &x) const {
        bign k = bign();
        k.len = 0;
        long long t[maxn];
        memset(t, 0, sizeof(t));
        for (int i = 1; i <= len; i++)t[i] = num[i] * x;
        for (int i = 1, g = 0; i <= len || g; i++) {
            k.num[++k.len] = (g + t[i]) % MOD;
            g = (g + t[i]) / MOD;
        }
        return k;
    }

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

    bign operator*=(const int &x) {
        return *this = *this * x;
    }

    bign operator*=(const ll &x) {
        return *this = *this * x;
    }

    bign operator/(const bign &x) const {
        if (x == 0)return bign();
        bign k = bign(), a = bign();
        k.flag = (flag == x.flag);
        k.len = len;
        for (int i = len; i >= 1; i--) {
            a = a * MOD + num[i];
            while (a >= abs(x)) {
                a -= abs(x);
                k.num[i]++;
            }
        }
//        if ((flag != x.flag) & a != 0)
//            k--;  //取模
        remove(k);
        return k;
    }

    bign operator/(const int &x) const {
        if (x == 0)return bign();
        bign k = bign();
        int a = 0;
        k.flag = (flag == (x >= 0));
        k.len = len;
        for (int i = len; i >= 1; i--) {
            a = a * MOD + num[i];
            k.num[i] = a / x;
            a %= x;
        }
//        if ((flag != x.flag) & a != 0)
//            k--;  //取模
        remove(k);
        return k;
    }

    bign operator/(const ll &x) const {
        if (x == 0)return bign();
        bign k = bign();
        int a = 0;
        k.flag = (flag == (x >= 0));
        k.len = len;
        for (int i = len; i >= 1; i--) {
            a = a * MOD + num[i];
            k.num[i] = a / x;
            a %= x;
        }
//        if ((flag != x.flag) & a != 0)
//            k--;  //取模
        remove(k);
        return k;
    }

    bign operator/=(const bign &x) {
        return *this = *this / x;
    }

    bign operator/=(const int &x) {
        return *this = *this / x;
    }

    bign operator/=(const ll &x) {
        return *this = *this / x;
    }

    bign operator%(const bign &x) const {
        if (x == 0)return bign();
        bign a = bign();
        for (int i = len; i >= 1; i--) {
            a = a * MOD + num[i];
            while (a >= abs(x))a -= abs(x);
        }
//        if (a == 0)return a;
//        if (flag && x.flag)return a;
//        if (flag && !x.flag)return a + x;
//        if (!flag && x.flag)return x - a;
//        return -a;//取模
        if (flag)return a;
        return -a;
    }

    bign operator%(const int &x) const {
        return *this % bign(x);
    }

    bign operator%(const ll &x) const {
        return *this % bign(x);
    }

    bign operator%=(const bign &x) {
        return *this = *this % x;
    }

    bign operator%=(const int &x) {
        return *this %= bign(x);
    }

    bign operator%=(const ll &x) {
        return *this %= bign(x);
    }

    friend bign pow(const bign &x, const bign &y) {
        bign ans = 1, cnt = x, w = y;
        while (w > 0) {
            if (w % 2 == 1)ans *= cnt;
            cnt *= cnt;
            w /= 2;
        }
        return ans;
    }

    friend bign pow(const int &x, const bign &y) {
        bign ans = 1, cnt = x, w = y;
        while (w > 0) {
            if (w % 2 == 1)ans *= cnt;
            cnt *= cnt;
            w /= 2;
        }
        return ans;
    }

    friend bign pow(const bign &x, const int &y) {
        bign ans = 1, cnt = x;
        int w = y;
        while (w) {
            if (w & 1)ans *= cnt;
            cnt *= cnt;
            w >>= 1;
        }
        return ans;
    }

    friend bign powmod(const bign &x, const bign &y, const bign &z) {
        bign ans = 1, cnt = x, w = y;
        while (w > 0) {
            if (w % 2 == 1)ans = ans * cnt % z;
            cnt = cnt * cnt % z;
            w /= 2;
        }
        return ans;
    }

    friend bign powmod(const int &x, const bign &y, const bign &z) {
        bign ans = 1, cnt = x, w = y;
        while (w > 0) {
            if (w % 2 == 1)ans = ans * cnt % z;
            cnt = cnt * cnt % z;
            w /= 2;
        }
        return ans;
    }

    friend bign powmod(const bign &x, const int &y, const bign &z) {
        bign ans = 1, cnt = x;
        int w = y;
        while (w) {
            if (w & 1)ans = ans * cnt % z;
            cnt = cnt * cnt % z;
            w >>= 1;
        }
        return ans;
    }

    friend bign powmod(const bign &x, const bign &y, const int &z) {
        bign ans = 1, cnt = x, w = y;
        while (w > 0) {
            if (w % 2 == 1)ans = ans * cnt % z;
            cnt = cnt * cnt % z;
            w /= 2;
        }
        return ans;
    }

    friend bign powmod(const int &x, const bign &y, const int &z) {
        bign ans = 1, cnt = x, w = y;
        while (w > 0) {
            if (w % 2 == 1)ans = ans * cnt % z;
            cnt = cnt * cnt % z;
            w /= 2;
        }
        return ans;
    }

    friend bign powmod(const bign &x, const int &y, const int &z) {
        bign ans = 1, cnt = x;
        int w = y;
        while (w) {
            if (w & 1)ans = ans * cnt % z;
            cnt = cnt * cnt % z;
            w >>= 1;
        }
        return ans;
    }

    friend bign max(const bign &x, const bign &y) {
        return x > y ? x : y;
    }

    friend bign min(const bign &x, const bign &y) {
        return x < y ? x : y;
    }
};

int main() {
    bign a, b;

    cin >> a >> b;
    cout << a + b << endl;
    cout << a - b << endl;
    cout << a * b << endl;
    cout << a / b << endl;
    cout << a % b << endl;

    return 0;
}
qq_50061740
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
麻将游戏 题解
Y的博客
12-14 1445
麻将游戏 题目 在一种"麻将"游戏中，游戏是在一个有W＊H格子的矩形平板上进行的。每个格子可以放置一个麻将牌，也可以不放（如图所示）。玩家的目标是将平板上的所有可通过一条路径相连的两张相同的麻将牌，从平板上移去。最后如果能将所有牌移出平板，则算过关。 这个游戏中的一个关键问题是：两张牌之间是否可以被一条路径所连接，该路径满足以下两个特性： 1. 它由若干条线段组成，每条线段要么是水平方向，要么是垂...
麻将游戏
蒟蒻こんにゃく
12-13 383
文章目录题目描述：分析：code：谢谢 题目描述： Description 在一种"麻将"游戏中，游戏是在一个有W＊H格子的矩形平板上进行的。每个格子可以放置一个麻将牌， 也可以不放（如图所示）。玩家的目标是将平板上的所有可通过一条路径相连的两张相同的麻将牌，从平板 上移去。最后如果能将所有牌移出平板，则算过关。 　　这个游戏中的一个关键问题是：两张牌之间是否可以被一条路径所连接，该路径满足以下两...
支持负数的高精度模板
Favbeer的博客
08-25 803
在网上都没有看到支持负数的高精度模板，所以自己写了下。 如果有什么bug，请指出 struct bign { int z[2005]; int len; bool ok; bign() { memset(z,0,sizeof(z)); len=1; ok=0; } bign(int x) { if(xok=1; *this=x; } bign
【题解】麻将游戏
weixin_30832983的博客
01-18 744
题目描述 　　在一种“麻将”游戏中，游戏是在一个有W×H格子的矩形平板上进行的。每个格子可以放置一个麻将牌，也可以不放（如图所示）。玩家的目标是将平板上的所有可通过一条路径相连的两张相同的麻将牌，从平板上移去。最后如果能将所有牌移出平板，则算过关。 　　这个游戏中的一个关键问题是：两张牌之间是否可以被一条路径所连接，该路径满足以下两个特性： 　　1、它由若干条线段组成，每条线段要么是...
高精度模板【高精度加减乘除模带负数判定】
雾腾腾
05-23 804
struct BN { int e[maxn],len,syb; BN(){memset(e,0,sizeof e);len=1;syb=1;} BN operator =(const char *a) { int j=0; if(!isdigit(a[0])&&a[0]=='-') syb=-1,len=strlen(a)-1,j++; else syb=1,len=s
题解 搜索综合
yours8的博客
01-28 996
几串代码大同小异
短学期第一日题解之WW的雀神之旅
qq_33254048的博客
06-29 4523
Description WW同学最近迷上了麻将，他总是自称雀神，他的欢乐豆数量会在凌晨刷新为N，然后WW同学就会进入快乐的雀神之旅，WW同学每开始一局麻将，就要付出640欢乐豆作为门票钱，每一局他都会得到或失去一些欢乐豆，当现有欢乐豆不足以支付门票时，WW不能将继续游戏。WW同学今天计划打M局游戏，请输出他最后停止游戏时所拥有的欢乐豆。 Input 题目为多组输入 第一行两个整数N和M（640≤n≤10^6,1<=M<=1000) 第二行会有M个整数a，代表WW每局游戏得到或者失去的欢乐豆数量（
湘南学院第一届程序设计大赛题解（XNPC—2022）
weixin_71856685的博客
11-28 949
本次“第一届程序设计大赛”为所有热爱编程的学生提供展示才能的平台。骄，败不馁 ，输赢不是最重要的，比赛中互相学习、互相进步才是最宝贵的奖品，让我们继续努力，加油学习，在交流中成长，在互动中进步。祝所有的ACMer不止 精彩不断”！！cc。
华北水利水电大学ACM第二届校赛题解
PleasantlY1的博客
04-14 1692
A: Xor and Sum 题目描述 给定一个大小为N的数组A，第i个元素为Ai。 问有多少的子区间[LR]，满足区间数值异或和等于区间数值和，即： AlxorAl+1xor…xorAr=Al+Al+1+…+Ar（l+1表示下标） a和b的xor即为a和b二进制表示按位取xor得到新数c的十进制表示 5和12的xor计算如下： 510=0101...
高精度模板（结构体）
weixin_30553837的博客
09-06 912
看到了一篇很棒的高精度板子，先抄下来，以后慢慢研究( -ω- ) 原文：https://blog.csdn.net/SkeletonKing233/article/details/92200315 # include <cstdio> # include <iostream> # include <cstring> # includ...
[C++] 麻将胡牌算法
weixin_34236869的博客
07-29 476
麻将的玩法规则众多，核心的玩法是一致的，本文将根据联发科2017年编程挑战赛的复赛题规则来实现。 牌的表示方式 ABCDEFGHI代表一到九萬，abcdefghi代表一到九条，123456789代表一到九饼 三种胡牌牌型 普通牌型，14张牌，形如：3+3+3+3+2。其中数字2代表两张相同的牌可成一组，形如XX。数字3代表三张相同或者连续的牌可成一组，形如XXX、XYZ。 龙七对，1...
C语言如何快速求值
2301_81985098的博客
08-26 602
4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数。一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？2、计算等式：m2 - n2 = (m + n)(m - n) = 168。1、则：x + 100 = n2, x + 100 + 168 = m2。6、由于 i * j = 168， j>=2，则。
c++命令模式
最新发布
qq_71286244的博客
08-30 380
c++命令模式详细介绍
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 2619
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 5331
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
【C++ 面试 - 内存管理】每日 3 题（三）
Newin2020的博客
08-26 1033
栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。因为操作系统会在底层对栈提供支持，会分配专门的寄存器存放栈的地址，栈的入栈出栈操作也十分简单，并且有专门的指令执行，所以栈的效率比较高也比较快。栈顶和栈底是之前预设好的，栈是向栈底扩展，大小固定，可以通过 ulimit -a 查看，由 ulimit -s 修改。堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 1111
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
怎么解决 hash 碰撞，用 C++ 实现 hashMap？
zhanghaiou07657的博客
08-29 469
如果要自己实现一个简单的哈希映射，可以定义一个结构体来表示哈希表中的节点，包含键值对和指向下一个节点的指针（如果采用链地址法）。在插入操作时，计算键的哈希值，若该位置已被占用且键不相同，则根据选择的解决碰撞的方法（如链地址法）将新元素插入到链表中。在查找操作时，同样计算键的哈希值，然后遍历对应的链表（如果是链地址法）来查找目标键值对。“哈希碰撞是在哈希函数计算过程中可能出现的不同输入产生相同哈希值的情况。链地址法是将哈希值相同的元素存储在一个链表中，当进行查找等操作时，遍历对应的链表来找到目标元素。
USACO题解：算法与解题策略
"USACO题解，包括章节和具体题目解析" USACO，全称为USA Computing Olympiad，是一项面向全球中学生的在线编程竞赛，旨在培养参赛者的算法设计和编程能力。NOCOW整理版的USACO题解集包含了多个章节和题目，帮助参赛...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值