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

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
3
1 1
1 1000
3 4
 
Sample Output
2
2
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;
}





2013年4月13日竞赛题目二

乘法测试
问题描述
CYL决定要教导du熊学习乘法。于是CYL需要生成两个整数来让du熊做乘法。于是CYL找到了他在镜面世界中的朋友------LYC来帮忙。CYL有m根现状标有数字的棍子,一个在左边一个在右边。而LYC有n根这样的根子,而镜面世界中的某些棍子和现实世界中的某些棍子存在着某种神秘相连的关系。
 
CYL通过以下方式来生成两个数字:
 
一开始,CYL初始化两个累加器A和B为0,然后重复以下步骤:
 
CYL首先选取一根现实世界中的棍子,暂且称之为棍子X。然后助手LYC会选取一根与X存在神秘相连关系的棍子Y,如果LYC找不到任何一根与X神秘相连的棍子则本次过程跳过然后算法结束。否则棍子X左边的数字会加入到A中,右边的数字加入到B中,而棍子Y左边的数字会加入到B中,右边的数字加入A中。
 
最终算法结束的时候CYL就得到了两个整数A和B。
 
为了考验du熊,CYL和LYC将会选取尽量多的棍子,即如果最多可以选取10根棍子,那么CYL和LYC将不会考虑导致最后只能选取少于10根棍子的选取方式。
 
由于镜面世界中没有熊ud,所以可怜的du熊没有助手,于是它只能算出所有可能的A*B值中最小的一个。
 
现在要求你找出du熊可以算出来的唯一结果。
 
输入格式
第一行一个整数T,代表测试数据个数。
 
接下来每个测试数据开头是两个整数m和n(1<m,n<=30),然后接下来一行共有2*m个整数,第i对整数分别代表现实世界中第i根棍子对应的左边和右边的数字 。
接下来一行通过同样的格式给出了镜面世界中n根棍子上左边和右边的数字。
 
之后一个整数C(0<=C<=500)表示共有C个相连关系,接着C行每行包含两个整数:a和b,表示现实世界中第a+1根棍子和镜面世界中第b+1根棍子间存在相连关系(显然a的范围是0..m-1,依此类推)。
 
输出格式
对于每个测试数据输出一行,表求du熊可以求出的乘法结果。
 
样例输入
2
2 2
1 2 1 3
2 2 2 3
2
0 1
1 0
3 3
1 2 3 1 4 3
2 2 3 3 4 4
5
0 0
1 0
1 1
1 2
2 0
 
样例输出
63
72
 
 
提示
在第一个测试数据中,CYL和LYC可以选取所有的棍子
在第二个测试数据中,只有当cyl先取第1和第2根棍子,而LYC对应选取第0和第1根棍子的时候,du熊才可以算出结果,其它的选取方法得到的数对于du熊来说都太大了。








  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hybrid-Astar是一种路径规划算法,它结合了A*算法(Astar)和RS距离(Reeds-Shepp距离)来寻找车辆的最优路径。使用Matlab实现这个算法需要2016a版本或更高版本。 首先,Hybrid-Astar算法以车辆的运动学模型为节点,在搜索过程中使用A*算法来计算当前点到终点的最短路径。A*算法通过综合考虑实际代价(g(n))和启发式代价(h(n))来选择下一个节点。在这里,h(n)函数的估计代价是通过计算当前点到终点的Astar距离和RS距离两者中的最大值得到的。 其次,RS距离是一种考虑了车辆转弯半径的距离度量方式。它使用车辆的运动学模型来计算车辆在转弯过程中可能遇到的最小转弯半径,并将其作为路径规划的一个重要因素。 在Matlab中实现Hybrid-Astar算法,可以使用基本的路径规划算法框架,并结合A*算法和RS距离的计算来实现。具体实现步骤可以按照以下方式进行: 1. 定义车辆的运动学模型,包括车辆的位置、速度、加速度等参数。 2. 定义启发式函数h(n),根据当前点到终点的Astar距离和RS距离两者中的最大值来估计代价。 3. 使用A*算法进行路径搜索,考虑实际代价g(n)和启发式代价h(n),选择下一个节点。 4. 在搜索过程中,根据车辆的运动学模型和RS距离计算车辆在转弯过程中的最小转弯半径。 5. 循环执行路径搜索,直到找到终点或搜索完所有可能的节点。 6. 返回最优路径。 这是Hybrid-Astar算法在Matlab中的一种实现方式,你可以根据具体需求进行调整和优化。以上是关于Hybrid-Astar matlab实现的简要介绍。<span class="em">1</span><span class="em">2</span> #### 引用[.reference_title] - *1* [Hybrid-Astar(混合A星算法)路径规划MATLAB代码](https://download.csdn.net/download/weixin_56691527/87614899)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [混合A星算法-Hybrid_Astar(matlab)](https://download.csdn.net/download/qq_49747343/13219383)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值