UVA 10123（欧拉定理 + 大数类）

最新推荐文章于 2021-06-11 18:08:00 发布
最新推荐文章于 2021-06-11 18:08:00 发布
阅读量287 收藏
点赞数
分类专栏： ACM之路 计算几何 文章标签： acm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/infinity_izayoi/article/details/52048611
版权

题目链接：

https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1154

题解：

公式：ans = 1 + C（2，n） + C（4，n）；
贴一个大数类的模板

大数类：

class integer
{
    friend ostream& operator<<(ostream&, const integer&);
    friend istream& operator>>(istream&, integer&);

    friend int compare(const integer, const integer);
    friend bool operator<(const integer, const integer);
    friend bool operator<=(const integer, const integer);

    friend integer operator<<(integer, int);

    friend integer operator+(integer, integer);
    friend integer operator-(integer, integer);
    friend integer operator*(integer, integer);
    friend integer operator/(integer, integer);
    friend integer operator^(integer, int);

public:
    integer() { };

    integer(int a)
    {
        signbit = (a >= 0 ? PLUS : MINUS);
        a = abs(a);
        while (a)
        {
            digits.push_back(a % 10);
            a /= 10;
        }
    };

    ~integer() { };

    void zero_justify(void);

private:
    // 表示大数的结构。数位按低位到高位的顺序存放。存储的是数位值，而不是数位的字符值。
    // 数字 1 用 ASCII 码为 1 的字符，而不是 ‘1’ 来表示。
    vector < char > digits; // 存放数位值。
    int signbit;        // 符号位。
};

integer operator+(integer, integer);
integer operator-(integer, integer);

// 重载输出符号<<。
ostream& operator<<(ostream& os, const integer& n)
{
    // 当为自然数时，不输出“+”号。
    os << (n.signbit > 0 ? "" : "-");
    for (int i = n.digits.size() - 1; i >= 0; i--)
        // 存放的是数位值，输出时要转换为数位的字符值。
        os << (char)('0' + n.digits[i]);
    return os;
}

// 重载输入符号>>。
istream& operator>>(istream& in, integer& n)
{
    // 读入表示大整数的字符串。
    string s;
    in >> s;

    if (s.length() == 0)
    {
        // 若长度为0，表示读入的是一个空字符串，应该要给予错误提示，但对于本题来说，不
        // 存在这种情况，故不考虑。若要完善，需要进一步处理此种情况。
    }

    // 在解析之前，理应判断该字符串是否是一个合法的大数表示，即开始一位为符号位，为“+”或
    // “-”，正整数“+”可以忽略，后面应该全部是数字字符，且不包含前导0。由于本题不存在此种情
    // 况，故不考虑，若要完善需进一步处理此种情况。

    // 解析符号位。
    if (isdigit(s[0]))
        n.signbit = PLUS;
    else
    {
        n.signbit = (s[0] == '+' ? PLUS : MINUS);
        s.erase(s.begin());
    }

    // 解析数字位，从低位到高位存放于动态数组中。
    n.digits.clear();
    for (int i = s.length() - 1; i >= 0; i--)
        n.digits.push_back((char)(s[i] - '0'));

    return in;
}

// 移除大数运算产生的前导0。
void integer::zero_justify(void)
{
    for (int i = digits.size() - 1; i >= 1; i--)
        if (digits[i] == 0)
            digits.erase(digits.begin() + i);
        else
            break;

    if (digits.size() == 1 && digits[0] == 0)
        signbit = PLUS;
}

// 比较两个数的大小，若相等，返回 0，若 a 大于 b，返回 1，若 a 小于 b，返回 -1。
int compare(const integer a, const integer b)
{
    // 若 a 为正，b 为负，则有 a 大于 b。
    if (a.signbit == PLUS && b.signbit == MINUS)
        return PLUS;

    // 若 a 为负，b 为正，则 a 小于 b。
    if (a.signbit == MINUS && b.signbit == PLUS)
        return MINUS;

    // 若两数符号相同，则 a 的数位长度大于 b 的数位长度，若 a 为正数，则有 a 大于 b，若 a
    // 为负数，有 a 小于 b，则将 a 的符号位乘以1作为结果返回即可。  
    if (a.digits.size() > b.digits.size())
        return PLUS * a.signbit;

    // 若两数符号相同，若a的数位长度小于b的数位长度，若 a 为正数，则 a 小于 b，若 a 为负数，
    // 则 a 大于 b，则将 a 的符号位乘以 -1 作为结果返回即可。    
    if (a.digits.size() < b.digits.size())
        return MINUS * a.signbit;

    // 两个数的数位长度相等，符号相等，则从低位到高位逐个比较数位值的大小。
    int marker = a.digits.size() - 1;
    while (marker >= 0)
    {
        if (a.digits[marker] > b.digits[marker])
            return PLUS * a.signbit;

        if (a.digits[marker] < b.digits[marker])
            return MINUS * a.signbit;

        marker--;
    }

    return 0;
}

// 小于比较符。
bool operator<(const integer a, const integer b)
{
    return compare(a, b) < 0;
}

// 小于等于比较符。
bool operator<=(const integer a, const integer b)
{
    return compare(a, b) <= 0;
}

// 左移操作。b 表示左移的位数。即将 a 乘以 10^b。
integer operator<<(integer a, int b)
{
    integer c = a;

    // 若 a 等于 0，则移位后仍为 0。
    if (a.digits.size() == 1 && a.digits[0] == 0)
        return c;

    // 向左移动 b 位，相当于在数位数组前插入 b 个 0。
    for (int i = 0; i < b; i++)
        c.digits.insert(c.digits.begin(), (char)(0));

    return c;
}

// 加法运算。从低位往高位进行，每一位相加产生的进位向高位传递，注意负数的处理，可以相应的
// 转变为减法来简化操作。
integer operator+(integer a, integer b)
{
    integer c;

    // 两数符号位相等，则最终符号位和原来的加数符号位相同。
    if (a.signbit == b.signbit)
        c.signbit = a.signbit;
    else
    {
        // 若两个加数为一正一负，则将其转换为减法操作。
        if (a.signbit == MINUS)
        {
            a.signbit = PLUS;
            c = b - a;
        }
        else
        {
            b.signbit = PLUS;
            c = a - b;
        }

        return c;
    }

    // 从动态数组的开始即低位开始相加，逐渐往前进位，如果有的话。
    int carry = 0;      // 进位。
    int maxsize = max(a.digits.size(), b.digits.size());
    int marker = 0;

    // 为两数添加前导 0，以使得数位相同，便于计算。
    while (a.digits.size() < maxsize)
        a.digits.push_back(char(0));
    while (b.digits.size() < maxsize)
        b.digits.push_back(char(0));

    // 逐位相加。
    while (marker < maxsize)
    {
        int t = a.digits[marker] + b.digits[marker] + carry;
        carry = t / 10;
        c.digits.push_back((char)(t % 10));

        marker++;
    }

    // 若最后一次进位为 1，则需在最高位加 1。
    if (carry)
        c.digits.push_back((char)(1));

    c.zero_justify();

    return c;
}

// 减法。为了保证借位能够成功终止，最好确保被减数不小于减数。同样可以在适当情况转变为加法来简化操作。
integer operator-(integer a, integer b)
{
    integer c;

    // 当某一个数为负数时，转换为加法。
    if (a.signbit == MINUS || b.signbit == MINUS)
    {
        b.signbit = MINUS * b.signbit;
        c = a + b;

        return c;
    }

    // 两个都为正数，若 a < b，则尽量保证被减数大于减数。
    if (a < b)
    {
        c = b - a;
        c.signbit = MINUS;

        return c;
    }
    else
        c.signbit = PLUS;

    int borrow = 0;     // 借位。
    int maxsize = a.digits.size();  // 被减数大于减数。
    int marker = 0;     // 计数器。

    // 为减数添加前导 0，便于计算。因为先前已经使得 a > b 且 a 和 b 均为正数。
    while (b.digits.size() < maxsize)
        b.digits.push_back(char(0));

    // 从低位开始逐位相减，不够的向高位借位。
    while (marker < maxsize)
    {
        int v = a.digits[marker] - borrow - b.digits[marker];
        if (v < 0)
        {
            v += 10;
            borrow = 1;
        }
        else
            borrow = 0;

        c.digits.push_back((char)(v % 10));

        marker++;
    }

    c.zero_justify();

    return c;
}

// 乘法，采用一行一行算的方法比单纯的反复加法更快且编写代码不会变复杂许多。每次操作都把第一个
// 乘数左移一个数位，然后把左移后的数乘以x的积加到最终结果中，其中x是第二个乘数对应的数字。尽
// 管用反复加法来实现这一步看起来不够精巧，但由于对于第二个乘数的每个数字，内层循环最多执行 9
// 次，实际上并没有浪费太多的时间，左移一个数位等价于用它乘以进位制的基数，在十进制里就是乘以 10。
integer operator*(integer a, integer b)
{
    integer c = integer(0), row = a;
    row.signbit = PLUS;

    for (int i = 0; i < b.digits.size(); i++)
    {
        for (int j = 0; j < b.digits[i]; j++)
            c = (c + row);

        row = row << 1;
    }

    c.signbit = a.signbit * b.signbit;
    c.zero_justify();

    return c;
}

// 除法运算。将余数和商不断左移，余数加上被除数的下一个数字，然后尝试减去除数。
integer operator/(integer a, integer b)
{
    integer c, row;
    row.signbit = PLUS;

    // 商的符号为 a 的符号乘以 b 的符号。
    c.signbit = a.signbit * b.signbit;

    int v;
    // 从数a的最高位开始除。
    for (int i = a.digits.size() - 1; i >= 0; i--)
    {
        row = row << 1;
        row.digits[0] = a.digits[i];

        // 当除数小于被除数，减去除数，对应位的商增 1。
        v = 0;
        while (b <= row)
        {
            v++;
            row = row - b;
        }

        // 将商左移 1 位，刚得到的商即为最低位。
        c = c << 1;
        c.digits[0] = (char)(v);
    }

    c.zero_justify();

    return c;
}

// 幂计算。幂就是反复作乘法，利用：a^n = a^(n / 2) * a^(n / 2) * a^(n mod 2)，可以减少乘
// 的次数。
integer operator^(integer a, int b)
{
    if (b == 0)
        return integer(1);

    if (b == 1)
        return a;

    if (b == 2)
        return a * a;

    return ((a ^ (b / 2)) ^ 2) * (a ^ (b % 2));
}

AC代码：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

#define PLUS    1
#define MINUS   -1

class integer
{
    friend ostream& operator<<(ostream&, const integer&);
    friend istream& operator>>(istream&, integer&);

    friend int compare(const integer, const integer);
    friend bool operator<(const integer, const integer);
    friend bool operator<=(const integer, const integer);

    friend integer operator<<(integer, int);

    friend integer operator+(integer, integer);
    friend integer operator-(integer, integer);
    friend integer operator*(integer, integer);
    friend integer operator/(integer, integer);
    friend integer operator^(integer, int);

public:
    integer() { };

    integer(int a)
    {
        signbit = (a >= 0 ? PLUS : MINUS);
        a = abs(a);
        while (a)
        {
            digits.push_back(a % 10);
            a /= 10;
        }
    };

    ~integer() { };

    void zero_justify(void);

private:
    vector < char > digits;
    int signbit;
};

integer operator+(integer, integer);
integer operator-(integer, integer);

ostream& operator<<(ostream& os, const integer& n)
{
    os << (n.signbit > 0 ? "" : "-");
    for (int i = n.digits.size() - 1; i >= 0; i--)
        os << (char)('0' + n.digits[i]);
    return os;
}

istream& operator>>(istream& in, integer& n)
{

    string s;
    in >> s;

    if (s.length() == 0)
    {
    }


    if (isdigit(s[0]))
        n.signbit = PLUS;
    else
    {
        n.signbit = (s[0] == '+' ? PLUS : MINUS);
        s.erase(s.begin());
    }


    n.digits.clear();
    for (int i = s.length() - 1; i >= 0; i--)
        n.digits.push_back((char)(s[i] - '0'));

    return in;
}


void integer::zero_justify(void)
{
    for (int i = digits.size() - 1; i >= 1; i--)
        if (digits[i] == 0)
            digits.erase(digits.begin() + i);
        else
            break;

    if (digits.size() == 1 && digits[0] == 0)
        signbit = PLUS;
}

int compare(const integer a, const integer b)
{
    if (a.signbit == PLUS && b.signbit == MINUS)
        return PLUS;


    if (a.signbit == MINUS && b.signbit == PLUS)
        return MINUS;


    if (a.digits.size() > b.digits.size())
        return PLUS * a.signbit;

    if (a.digits.size() < b.digits.size())
        return MINUS * a.signbit;

    int marker = a.digits.size() - 1;
    while (marker >= 0)
    {
        if (a.digits[marker] > b.digits[marker])
            return PLUS * a.signbit;

        if (a.digits[marker] < b.digits[marker])
            return MINUS * a.signbit;

        marker--;
    }

    return 0;
}
bool operator<(const integer a, const integer b)
{
    return compare(a, b) < 0;
}

bool operator<=(const integer a, const integer b)
{
    return compare(a, b) <= 0;
}

integer operator<<(integer a, int b)
{
    integer c = a;

    if (a.digits.size() == 1 && a.digits[0] == 0)
        return c;

    for (int i = 0; i < b; i++)
        c.digits.insert(c.digits.begin(), (char)(0));

    return c;
}

integer operator+(integer a, integer b)
{
    integer c;


    if (a.signbit == b.signbit)
        c.signbit = a.signbit;
    else
    {
        if (a.signbit == MINUS)
        {
            a.signbit = PLUS;
            c = b - a;
        }
        else
        {
            b.signbit = PLUS;
            c = a - b;
        }

        return c;
    }
    int carry = 0;
    int maxsize = max(a.digits.size(), b.digits.size());
    int marker = 0;

    while (a.digits.size() < maxsize)
        a.digits.push_back(char(0));
    while (b.digits.size() < maxsize)
        b.digits.push_back(char(0));

    while (marker < maxsize)
    {
        int t = a.digits[marker] + b.digits[marker] + carry;
        carry = t / 10;
        c.digits.push_back((char)(t % 10));

        marker++;
    }

    if (carry)
        c.digits.push_back((char)(1));

    c.zero_justify();

    return c;
}

integer operator-(integer a, integer b)
{
    integer c;

    if (a.signbit == MINUS || b.signbit == MINUS)
    {
        b.signbit = MINUS * b.signbit;
        c = a + b;

        return c;
    }

    if (a < b)
    {
        c = b - a;
        c.signbit = MINUS;

        return c;
    }
    else
        c.signbit = PLUS;

    int borrow = 0;
    int maxsize = a.digits.size();
    int marker = 0;

    while (b.digits.size() < maxsize)
        b.digits.push_back(char(0));

    while (marker < maxsize)
    {
        int v = a.digits[marker] - borrow - b.digits[marker];
        if (v < 0)
        {
            v += 10;
            borrow = 1;
        }
        else
            borrow = 0;

        c.digits.push_back((char)(v % 10));

        marker++;
    }

    c.zero_justify();

    return c;
}

integer operator*(integer a, integer b)
{
    integer c = integer(0), row = a;
    row.signbit = PLUS;

    for (int i = 0; i < b.digits.size(); i++)
    {
        for (int j = 0; j < b.digits[i]; j++)
            c = (c + row);

        row = row << 1;
    }

    c.signbit = a.signbit * b.signbit;
    c.zero_justify();

    return c;
}

integer operator/(integer a, integer b)
{
    integer c, row;
    row.signbit = PLUS;

    c.signbit = a.signbit * b.signbit;

    int v;
    for (int i = a.digits.size() - 1; i >= 0; i--)
    {
        row = row << 1;
        row.digits[0] = a.digits[i];

        // 当除数小于被除数，减去除数，对应位的商增 1。
        v = 0;
        while (b <= row)
        {
            v++;
            row = row - b;
        }

        // 将商左移 1 位，刚得到的商即为最低位。
        c = c << 1;
        c.digits[0] = (char)(v);
    }

    c.zero_justify();

    return c;
}

integer operator^(integer a, int b)
{
    if (b == 0)
        return integer(1);

    if (b == 1)
        return a;

    if (b == 2)
        return a * a;

    return ((a ^ (b / 2)) ^ 2) * (a ^ (b % 2));
}

int main()
{
    int s;
    integer n;
    scanf("%d", &s);
    while(s--)
    {
        cin >> n;
        cout << ((n ^ 4) - integer(6) * (n ^ 3) +  integer(23) * (n ^ 2) - integer(18) * n +  integer(24)) / integer(24) << endl;
    }
    return 0;
}
Infinity_Izayoi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
UVa-writeup:使用C ++编写UVa
03-07
UVa写入 使用C ++编写UVa OJ： ： 等级 基于 ★★ ★★ ★★★ ★★★★ ★★★★★ 未排名
扒一扒那些叫欧拉的定理们（四）——平面几何欧拉定理美学鉴赏
magic2728的博客
06-04 6541
早点关注我，精彩不迷路！上一篇我们聊完了空间立体几何范畴内的欧拉定理及其抽象形式，相关内容回顾请戳：扒一扒那些叫欧拉的定理们（三）——简单多面体欧拉定理的抽象形式扒一扒那些叫欧拉的定理们（...
uva 10213 How Many Pieces of Land （欧拉公式计算多面体）
weixin_34392435的博客
06-03 147
题意：在一个圆上取n个点，求最多能将圆分为多少块； 思路：欧拉公式计算多面体； 欧拉公式：简单多面体的顶点数V、面数F及棱数E之间的关系为V+F-E=2; 首先考虑点数v，有n个在圆上的点，任取一点x，考虑与x相连的每条对角线，假设对角线左边有i个顶点，则右边应有（n-2-i）个顶点，这些顶点相互连接可以产生i*(n-i-2)个顶点，再将所有的x与所有的对角线l求和。每个交点分别算了...
UVA 10123 No Tipping
已注销的博客
08-17 553
分析这是一双支点的杠杆的题目，问初始时，依次有选择地拿去杠杆上的有质量的物块后，杠杆是否平衡。给出选择。杠杆如何平衡？ 因为有两个支点，对于任一支点，如果左右两侧物块的力矩和相等，则杠杆平衡，若两支点均不能满足则杠杆失衡。 需要注意的是，因为杠杆本身具有重量，比如以右侧支点研究对象，那么杠杆可以视为距该支点1.5单位的一个质量为W的物块，会影响平衡。这里可以使用逆向思维，仅作思路简化。如何拿，不
UVa Problem 10213 How Many Pieces of Land? （土地分割）
寂静山林
05-31 3383
// How Many Pieces of Land? （土地分割） // PC/UVa IDs: 110602/10213, Popularity: B, Success rate: average Level: 2 // Verdict: Accepted // Submis
Uva--10123（回溯，强剪枝）
dingdi3021的博客
07-20 109
2014-07-1923:49:21 Problem A - No Tipping As Archimedes famously observed, if you put an object on a lever arm, it will exert a twisting force around the lever's fulcrum. This twisting is call...
uva11859nim游戏 + 求素因子个数.cpp
09-12
uva11859nim游戏 + 求素因子个数.cpp
UVa11887 Tetrahedrons and Spheres
最新发布
04-20
测试数据
UVa11595 Crossing Streets EXTREME
03-07
UVa11595 Crossing Streets EXTREME 测试数据
AIML.zip_UVA_UVA 499
09-20
UVA 499 Solution in C/ C++
UVA 10213 - How Many Pieces of Land ? （平面图欧拉公式）
Change the world by program.
08-28 365
题目链接 https://cn.vjudge.net/problem/UVA-10213 【题意】 一个椭圆上有N个点，把他们两两连接，问最多能将椭圆划分成多少个部分 【思路】 平面图的欧拉公式，V−E+F=2V−E+F=2V - E + F = 2，其中V表示顶点个数，E表示边的个数，F表示面的块数 减去最外面的无限大的面，所求 ans=E−V+1ans=E−V+1ans = E - ...
How Many Pieces of Land ? UVA - 10213
海绵的博客
07-14 375
欧拉平面公式证明：点击打开链接 题目链接：点击打开链接 import java.math.BigInteger; import java.util.*; /* 第一道java题，简单在不用模拟，但是要记住这一堆规则 1. 头文件 import java.math.BigInteger; import java.util.*;//大数头文件和 一些标准头文件， 2. 函数名必须写Main(),...
UVA 10213 How Many Pieces of Land? 欧拉定理
码代码的猿猿
02-02 1958
欧拉定理 V-E+F=C+1 Problem G How Many Pieces of Land? Input: Standard Input Output: Standard Output Time Limit: 3 seconds   You are given an elliptical shaped land and you are asked to ch
UVa10213 - How Many Pieces of Land ?
多看多听多总结
09-22 963
import java.util.Scanner; import java.math.BigInteger; class Main { public static void main(String[] args) { Scanner cin = new Scanner(System.in); int n; n = cin.nextInt(); while (n-- >
UVa 10213 How Many Pieces of Land ?
QWsin的博客
12-14 1193
欧拉公式V−E+F=2
计算几何讲义——计算几何中的欧拉定理
weixin_30877755的博客
08-03 190
在处理计算几何的问题中，有时候我们会将其看成图论中的graph图，结合我们在图论中学习过的欧拉定理，我们可以通过图形的节点数(v)和边数(e)得到不是那么好求的面数f。 平面图中的欧拉定理： 定理：设G为任意的连通的平面图，则v-e+f=2，v是G的顶点数，e是G的边数，f是G的面数。 证明：其实有点类似几何学中的欧拉公式的证明方法，这里采用归纳证明的方法。 对m...
扒一扒那些叫欧拉的定理们（五）——平面几何欧拉定理的证明
magic2728的博客
06-11 4099
早点关注我，精彩不迷路！在前面的文章中，我们介绍了空间几何内的欧拉定理及其扩展，上一篇中又讲到了平面几何欧拉定理，相关内容请戳：扒一扒那些叫欧拉的定理们（四）——平面几何欧拉定理美学鉴赏扒...
uva 10213 How Many Pieces of Land 分割圆 高精度
YueLing's Blog
09-12 793
Problem： 一个椭圆上有N个点，把他们两两连接，问最多能划分成多少个部分。
robocup uva
11-28
RoboCup UVA是荷兰阿姆斯特丹大学的一个机器人足球比赛。UVA代表“Universiteit van Amsterdam”，即阿姆斯特丹大学的荷文名字。RoboCup UVA是RoboCup联合会下属的一个赛事，旨在推动机器人技术和人工智能在足球领域...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值