YBTOJ：方程的解（组合数学）（插板法）

最新推荐文章于 2022-03-24 21:25:13 发布
最新推荐文章于 2022-03-24 21:25:13 发布
阅读量402 收藏
点赞数 1
分类专栏： 数学 文章标签： 组合数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BUG_Creater_jie/article/details/119082684
版权

文章目录

题目描述

请添加图片描述

解析

第一感觉：啥都没感觉出来。。。
直接拿动态规划+高精做的
但是只能拿40
重新分析一下这道题：
g（x）首先可以拿快速幂很容易的求出来
问题就转化为了**把g(x)个东西分成k份的方案数
其实答案就是C(k-1,n-1)
为什么是这样？
介绍一种新的方法：隔板法
本题画一下就是：
请添加图片描述
那么不难发现，一共有n-1个空隙，插入k-1个板（题目已经说明1,1,2和2,1,1是不一样的方案）
所以就可以得出组合数的结论了

代码

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

using namespace std;

typedef long long ll;

const int maxn = 1000;
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;
    }
};


#define ll bign
const int N=4e5+100;
const int mod=1000;
int t,k,x;
int n;
long long ksm(int x,int p){
	long long tot=1,res=x;
	while(p){
		if(p&1) tot=tot*res%mod;
		res=res*res%mod;
		p>>=1;
	}
	return tot%mod;
}
int main(){
	scanf("%d%d",&k,&x);
	n=ksm(x,x);
	//n-=k;
	ll ans=1;
	for(int i=2;i<=n-1;i++) ans*=i;
	for(int i=2;i<=k-1;i++) ans/=i;
	for(int i=2;i<=n-k;i++) ans/=i;
	cout<<ans;
}
/*
WW.WBBBBB
*/
wind__whisper
关注
专栏目录
组合数学+高精度+快速幂——方程的解
行走天涯的豆沙包的博客
02-13 311
方程的解 题目描述 佳佳碰到了一个难题，请你来帮忙解决。 对于不定方程a1+a2+…+ak-1+ak=g(x)，其中k≥2且k∈N，x是正整数，g(x)=x^x mod 1000(即x^x除以1000的余数)，x，k是给定的数。我们要求的是这个不定方程的正整数解组数。 举例来说，当k=3，x=2时，分别为(a1,a2,a3)=(2,1,1)’(1,2,1)，(1,1,2)。 输入格式 输入文件eq...
分配问题（插板法）
默的博客
09-13 1497
题目1：有 n 个小球，放入 m 个盒子，每个盒子里至少 1 个，求有多少种情况？ 解析： 我们可以把问题转化为：有 n 个小球，所以在小球之间有 n−1 个空隙我们可以把问题转化一下，有~n~个小球，所以在小球之间有~n-1~个空隙我们可以把问题转化一下，有 n 个小球，所以在小球之间有 n−1 个空隙 放入 m 个盒子，说明要把小球分成 m 份，所以需要在小球之间的空隙中插&nb.
解析组合数学（Analytic Combinatorics）
01-04
解析组合数学的高清英文版本，对于组合数学的学习、算法思维的养成具有很大的好处。将教会大家精确定量预测大型组合结构的性质
组合数学(隔板法) + 高精度 - 方程的解 - AcWing 1308
njuptACMcxk的博客
07-16 501
组合数学(隔板法) + 高精度 - 方程的解 - AcWing 1308 佳佳碰到了一个难题，请你来帮忙解决。佳佳碰到了一个难题，请你来帮忙解决。佳佳碰到了一个难题，请你来帮忙解决。 对于不定方程a1+a2+⋯+ak−1+ak=g(x)，其中k≥1且k∈N∗，x是正整数，对于不定方程 a_1+a_2+⋯+a_{k−1}+a_k=g(x)，其中 k≥1 且 k∈N∗，x 是正整数，对于不定方程a1​+a2​+⋯+ak−1​+ak​=g(x)，其中k≥1且k∈N∗，x是正整数， g(x)=xx mod
AcWing 1308. 方程的解 (组合数（“隔板法“、不定方程正整数解的个数）、高精度、快速幂)
SongyangJi
09-14 261
1308. 方程的解 xx(mod  1000)x^x (\mod 1000)xx(mod1000)可以快速幂求出，不是重点。 然后实际上就是求不定方程的正整数解的个数，运用隔板法就可以解决。 最终答案Cn−1k−1C_{n-1}^{k-1}Cn−1k−1​ 但是由于不能取模，所以还得要手写高精度。 #include <stdio.h> using namespace std; const int N = 150; int k,x,f[1010][110][N]; int qm(int a
【浅谈折半搜索】POJ1186[方程的解数]题解
ZigZagK的博客
05-21 1248
【浅谈折半搜索】POJ1186题解。
VPX连接器连接关系示意图：包含前插板后插板和背板的连接关系
最新发布
05-05
在VPX系统中，连接器起着至关重要的作用，它们负责将不同的组件如前插板、后插板以及背板之间进行物理和电气上的连接。本文将详细介绍这些连接器的具体连接关系。 ### 前插板与背板的连接 前插板通常包含处理器和...
排列组合--插板法、插空法、捆绑法.doc
10-10
排列组合--插板法、插空法、捆绑法 排列组合是一种重要的数学思想，应用于解决各种组合问题。插板法是其中的一种重要方法，它可以将元素分配到不同的组中，解决元素分配问题。 插板法的思想是将元素排成一行，然后...
插板法原理及应用.pdf
03-16
插板法是一种在组合数学中解决分配问题的技巧，它主要应用于将相同元素分成不同组的问题。该方法的核心思想是通过插入隔板来分隔元素，使得每个元素都被分配到一个组内。以下是对插板法原理及应用的详细解释： 1. ...
排列组合插板法、插空法、捆绑法.doc
09-27
排列组合插板法、插空法、捆绑法.doc
组合数学-浅谈：专题
洛谷棕名用户的博客（兔子的博客）
07-26 558
从找规律到组合数学 引入 我们，先来看一道简单的题目： 兔子问题（传送门） 我们这里就不进行累述了。题目呢，你们看看就行。 这是一道经典的题目，让我们思考一下 你是准备用什么方法呢？ 找规律？ 找规律 组合数学 组合数学中的基本计数原理I 加法原理 乘法原理 详细分析组合数学 1. 2. 3. 4. 5. 组合数学中的经典问题 数的划分 错排问题 出入栈问题 括号序列问题 二叉树计数 凹多边形划分...
组合数学详解
Deep_Kevin的娱乐空间
06-28 650
正题 排列组合 (a+b)m=∑i=0mCmiaibm−i∑i=0mCniCmi=Cn+mm∑i=0niCni=2n−1n∑i=0ni2Cni=2n−2n(n+1)∑i=0nCik=Cn+1k+1CnrCrk=CnkCn−kr−k \\(a+b)^m=\sum_{i=0}^m C_m^i a^ib^{m-i} \\\sum_{i=0}^m C_n^i C_m^i =C_{n+m}^{m} \\\sum_{i=0}^n iC_n^i=2^{n-1}n \\\sum_{i=0}^n i^2C_n^i =2^{n
组合数学（超详细！！！）
anglanjing7414的博客
08-26 3322
加法原理 今天您想给orz做一道题。 您有10道数学题，5道物理题，5道oi题，这些题orz都不会做。 可惜您只能用其中一道题来考orz. 请问您有多少种方法让orz爆零？ 10+5+5 = 20 假设您有很多种手段，使用每种手段都可以达成目标。 那么：每种手段的方法数之和，就是达成目标的方法数。 乘法原理 今天您想给orz做三道题：数学、物理、oi各一题。 您...
幻方算法（Magic Square）学习笔记
12-27 303
&lt;style type="text/css"&gt; &lt;!-- @page {margin:2cm} p {margin-bottom:0.21cm} --&gt; &lt;/style&gt; 一、幻方按照阶数可分成了三类，即奇数阶幻方、双偶阶幻方、单偶阶幻方。 二、奇数阶幻方（劳伯法） 奇数阶幻方最经典的填法是罗伯法。填写的方法是： 把1（或最小的数）放在第...
HDU5201-The Monkey King
luyan0408的博客
05-31 232
题目 题目大意 简化题意：1~n个不同盒子，放入m个相同小球，盒子可空，但是1号盒子的球数必须严格最多，问合法方案数。 分析 简化问题 如果没有1号盒子严格最多的限制，就变成了一个插板的问题。 也就是x1+x2……+xn=mx_1+x_2……+x_n=mx1​+x2​……+xn​=m这类不定方程求非负整数解的问题，插板法解决。 容斥 如果枚举猴王（1号盒子）的球数为i 那么问题就变成不定方程并且0<=x<=i0<=x<=i0<=x<=i，加了一个上限。 上限通常会用容斥转
组合数学：插板法
wangqianqianya的博客
08-28 4040
问题引出：把10个球放进三个盒子，每个箱子至少一个有多少种分法？ 插板法 在n个元素的n-1个间隙间插入b个板子，这样就可以将元素分成b+1份了，每份至少1个元素。 所以这题答案为C(9,2) 例二：把10个球放进三个盒子有多少种分法？ C(n+m-1,m-1) 这里盒子可以为空,我们可以预先在3个盒子里都放一个球，则问题转化为将13个球放进3个盒子里，每个盒子至少一个有多少中放法...
学组合数学心得与题解（一）——组合计数
一个蒟蒻的博客
07-31 4229
今天我在某网站上稍微学习了一下组合数学，准确来讲，今天就看了看组合计数，然后做了两道题，在这里主要跟大家分享一下我的学习心得。
模板：LGV引理（线性代数）
BUG_Creater_jie的博客
03-24 1713
LGV引理
凌华cPCI3970用户手册：连接器与后插板指南
"凌华cpci3970用户手册提供了关于连接器定义和后插板使用说明，详细阐述了3U CompactPCI PlusIO接口的Intel Core i7处理器刀片的详细规格和操作指南。手册涵盖了从2.00到2.03的修订历史，修正了电源消耗表格和J2VGA...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值