Baidu Astar Contest 2013-04-13 Regional (Guangzhou)

最新推荐文章于 2024-08-22 08:59:51 发布

lllcfr1

最新推荐文章于 2024-08-22 08:59:51 发布

阅读量1.4k

点赞数

分类专栏： Algorithm

Algorithm 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

2013年4月13日竞赛题目一

du熊的机器人

Description

du熊正在玩一个别人刚送给它的机器人。这个机器人只能在一个棋盘中行走，棋盘的左上角格子为(0, 0)，右下角格子为(X, Y)。

du熊控制这个机器人从棋盘的左上角，走到右下角，再从右下角回到左上角。当机器人从左上角走到右下角的过程中，如果它当前所在格子为(x, y)，则它只能走到(x+1, y)或(x, y+1)的格子；当机器人从右下角走回左上角的过程中，如果它当前所在的格子为(x, y)，则它只能走到(x-1, y)或(x, y-1)的格子。并且du熊要求机器人从左上角走到右下角再走回左上角的整个过程中，最多经过同一个格子一次。

请你帮du熊计算出这个机器人一共有多少种不同的路线。

Input

输入的第一行为一个正整数T(0<T<=50)，表示数据组数。

接下来的T行，每行有两个整数，分别表示X和Y。(1<=X,Y<=1000)

Output

对每组输入数据，输出一个整数，表示机器人不同的路线数量。

Sample Input

1 1

1 1000

3 4

Sample Output

100

Analysis: High precision DP, no idea about the output range, set MAXLEN = 10000 may be too small for complete answer, but may be too large to successfully compile (when MAXLEN is 100, default compiler handles it properly).

BTW: Baidu's contest platform really sucks!

#include <cstring>
#include <iostream>

using namespace std;

const int MAXLEN = 10000;

class BigInteger {
public:
        int len, s[MAXLEN];

        BigInteger() { (*this) = 0; };
        BigInteger(int inte) { (*this) = inte; };
        
        friend ostream& operator<<(ostream &cout, const BigInteger &x);

        BigInteger operator=(int inte);
        BigInteger operator*(const BigInteger &b);
        BigInteger operator+(const BigInteger &b);
};

ostream& operator<<(ostream &cout, const BigInteger &x) {
        for (int i = x.len; i >= 1; --i)
                cout << x.s[i];
        return cout;
}

BigInteger BigInteger::operator=(int inte )
{
        if (inte == 0) {
                len = 1;
                s[1] = 0;
                return (*this);
        };
        for (len = 0; inte > 0; ) {
                s[++len] = inte % 10;
                inte /= 10;
        };
        return (*this);
}

BigInteger BigInteger::operator+(const BigInteger &b)
{
        int i;
        BigInteger c;
        c.s[1] = 0;
        for (i = 1; i <= len || i <= b.len || c.s[i]; i++) {
                if (i <= len) c.s[i] += s[i];
                if (i <= b.len) c.s[i] += b.s[i];
                c.s[i+1] = c.s[i] / 10;
                c.s[i] %= 10;
        }
        c.len = i - 1;
        if (c.len == 0) c.len=1;
        return c;
}

BigInteger BigInteger::operator*(const BigInteger &b)
{
        int i ,j;
        BigInteger c;
        c.len = len + b.len;
        for (i = 1; i <= c.len; ++i) c.s[i] = 0;
        for (i = 1; i <= len ; ++i)
                for (j = 1; j <= b.len ; ++j)
                        c.s[i + j - 1] += s[i] * b.s[j] ;
        for (i = 1; i < c.len; ++i) {
                c.s[i + 1] += c.s[i] / 10;
                c.s[i] %= 10;
        }
        while(c.s[i]) {
                c.s[i + 1] = c.s[i] / 10;
                c.s[i] %= 10;
                ++i;
        }
        while(i >1 && !c.s[i] ) --i;
        c.len=i ;
        return c ;
}

BigInteger dp[2][1001][1001];

int main() {
        int T;
        cin >> T;
        while (T--) {
                int x, y;
                cin >> x >> y;
                memset(dp, 0, sizeof(dp));
                int n = x + y;
                int t = 0;
                dp[0][0][0] = 1;
                for (int step = 1; step <= n; ++step) {
                        int k = step%2;
                        int start = (step <= x) ? 0 : (step - x);
                        int end = (start + x <= y) ? start + x : y;
                        for (int i = start; i <= end; ++i) {
                                for (int j = i; j <= end; ++j) {
                                        if (step != n && i == j) {
                                                dp[k][i][j] = 0;
                                                continue;
                                        }
                                        dp[k][i][j] = dp[t][i][j];
                                        if (i > 0)
                                                dp[k][i][j] = dp[k][i][j] + dp[t][i - 1][j];
                                        if (j > 0)
                                                dp[k][i][j] = dp[k][i][j] + dp[t][i][j - 1];
                                        if (i > 0 && j > 0)
                                                dp[k][i][j] = dp[k][i][j] + dp[t][i - 1][j - 1];
                                }
                        }
                        t = k;
                }
                cout << dp[t][y][y] * 2 << '\n';
        }
        return 0;
}