2016"百度之星" - 资格赛（Astar Round1） 题解

最新推荐文章于 2018-06-11 20:53:16 发布
最新推荐文章于 2018-06-11 20:53:16 发布
阅读量663 收藏
点赞数
分类专栏： 比赛题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nike0good/article/details/51443132
版权

Problem B

度熊面前有一个全是由1构成的字符串，被称为全1序列。你可以合并任意相邻的两个1，从而形成一个新的序列。对于给定的一个全1序列，请计算根据以上方法，可以构成多少种不同的序列。
1≤N≤200

#include <iostream>
#include <cmath>
#include <vector>
#include <cstdio>
#include <string>
#include <algorithm>

using namespace std;

#define LL long long
#define ULL unsigned long long
#define LD long double

#define Rep(x,y,i) for (int i=x;i<y;i++) //[x,y)
#define RepD(x,y,i) for (int i=x;i>y;i--) //(y,x]
#define Mem(X) memset(X,0,sizeof(X));
#define Pr(X) cout<<" "<<#X<<"="<<X<<" ";
#define PrL(X) cout<<#X<<" = "<<X<<endl;
#define PrLL cout<<endl;
using namespace std;
const double EPS = 1e-10;


#define IntMod 10000
struct BigInt
{
private:
    vector<int> A;
    bool Positive;
    int VecNum;

public:
    //Constructors
    inline int GetLength(LL a) {int t=0; while (a>0) {a/=IntMod; t++;} return t;}
    BigInt() { Positive = 1; VecNum = 0; }
    BigInt(const BigInt &a) { A = a.A; VecNum = a.VecNum; Positive = a.Positive; }
    BigInt(string s)
    {
        A.reserve(100);
        if (s == "-0") { A.push_back(0); Positive = 1; VecNum = 1; return; }
        int kk = 3; int kl = 0;
        int l = s.length();
        int j = l - 1;
        if (s[0] == '-') { Positive = 0; kk++; kl++; }
        else Positive = 1;
        while (j>kk)
        {
            int t = 0;
            Rep(0, 4, i) { t *= 10; t += s[j - (3 - i)] - '0'; }
            j -= 4;
            A.push_back(t);
        }
        int t = 0;
        int k = j + 1;
        Rep(kl, k, i) { t *= 10; t += s[i] - '0'; }
        A.push_back(t);
        VecNum = A.size();
    }
    BigInt(const LL &b)
    {
        LL a=b;
        Positive=(a>=0);
        VecNum=GetLength(abs(a));
        A.resize(VecNum);
        Rep(0,VecNum,i)
        {
            A[i]=a%IntMod;
            a/=IntMod;
        }
    }
    //BigInt& operator = (BigInt& a) { VecNum=a.VecNum; Positive=a.Positive; A=a.A; }
    BigInt& operator = (const string s) { BigInt x(s); *this=x; }
    BigInt& operator = (LL s) { BigInt x(s); *this = x; }

    //Basic Math Functions
    friend BigInt abs(BigInt a) { a.Positive=1; return a; }
    friend bool isnegative(BigInt &a) { return a.Positive; }
    BigInt& operator - () { Positive = !(Positive); return *this; }

    // Ostream and Instream
    friend ostream& operator << (ostream &out, BigInt &a)
    {
        if (a.VecNum==0)
        {
            out<<"0";
            return out;
        }   //Bug Fixed if there is a BigInt constructed by the default constructor
        if (!a.Positive) out << "-";
        out << a.A[a.VecNum - 1];
        RepD(a.VecNum - 2, -1, i)
        {
            if (a.A[i] == 0) { out << "0000"; continue; }
            Rep(0, (int)(4 - log(a.A[i]) / log(10) - EPS), j) out << '0';
            out << a.A[i];
        }
        return out;
    }
    friend istream& operator >> (istream &in, BigInt &a)
    {
        string s;
        in >> s;
        int L = s.length() - 1;int i = 0;bool flag = 0;
        if (s[i] == '-') { i++; flag = 1; }
        while (s[i] == '0' && i < L) i++;
        string b(s.begin() + i, s.end());
        if (flag) b.insert(0, "-");
        a = BigInt(b);
        return in;
    }

    //Bool Operators
    bool operator < (const BigInt &b) const
    {
        if (Positive &&  b.Positive)
        {
            if (VecNum != b.VecNum) return (bool)(VecNum<b.VecNum);
            RepD(VecNum-1, -1, i)
                if (A[i] != b.A[i])
                    return (bool)(A[i]<b.A[i]);
            //Bug Fixed that there should be a RepD rather that Rep
            return 0;
        }
        if (!Positive &&  b.Positive) return 1;
        if (Positive && !b.Positive)  return 0;
        BigInt a = b;
        BigInt c = (*this);
        if (!c.Positive && !a.Positive) return !((-c) < (-a));
        return 1;
    }
    bool operator >  (const BigInt &b) const { return !((*this)<b); }
    bool operator == (const BigInt &b) const { return (Positive == b.Positive && A == b.A && VecNum == b.VecNum); }
    bool operator <= (const BigInt &b) const { return (*this == b) || (*this < b); }
    bool operator >= (const BigInt &b) const { return (*this == b) || !(*this < b);}
    bool operator != (const BigInt &b) const { return !(*this == b); }

    bool operator <  (const string b) const { BigInt x(b); return (*this) < x; }
    bool operator == (const string b) const { BigInt x(b); return x==(*this) < x; }

    bool operator <  (const LL& b) const { BigInt x(b); return *this < x; }
    bool operator == (const LL& b) const { BigInt x(b); return *this == x; }

    //Function of Plus and Minus
    BigInt operator - (const BigInt &b) const
    {
        BigInt x=*this;
        BigInt y=b;

        if (!x.Positive &&  y.Positive) return -(-x + y);
        if ( x.Positive && !y.Positive) return x + y;
        if (!x.Positive && !y.Positive) return (-y) - (-x);
        if (x<y) return  -(y - x);

        int L = max(x.VecNum, y.VecNum);
        y.A.resize(L);
        x.A.resize(L);
        Rep(0, L, i)
        {
            x.A[i] -= y.A[i];
            if (x.A[i]<0) { x.A[i] += IntMod; x.A[i + 1]--; }
        }
        while (x.A[L - 1] == 0 && ((L-1)!=0) ) { x.VecNum--; x.A.pop_back(); L--; }
        return x;
    }
    BigInt operator + (const BigInt &b) const
    {
        BigInt x=*this;
        BigInt y=b;

        if (!x.Positive &&  y.Positive) return y - (-x);
        if (!x.Positive && !y.Positive) return -(-x + (-y));
        if ( x.Positive && !y.Positive)  return x - (-y);
        int L = max(x.VecNum, y.VecNum);
        x.A.resize(L + 1);
        y.A.resize(L + 1);
        for (int i = 0; i<L; i++) x.A[i] += y.A[i];
        for (int i = 0; i<L; i++)
        { x.A[i + 1] += x.A[i] / IntMod; x.A[i] %= IntMod; }
        x.VecNum = L;
        if (x.A[L]) x.VecNum++;
        else x.A.erase(x.A.begin() + L);
        return x;
    }
    BigInt operator - (const LL &b) const { BigInt y(b); return *this - y; }
    BigInt operator + (const LL &b) const { BigInt y(b); return *this + y; }
    BigInt operator - (const string b) const { BigInt y(b); return *this - y; }
    BigInt operator + (const string b) const { BigInt y(b); return *this + y; }
    BigInt operator += (const BigInt& b) { *this=*this+b; return *this; }
    BigInt operator += (const LL& b)     { *this=*this+b; return *this; }
    BigInt operator -= (const BigInt& b) { *this=*this-b; return *this; }
    BigInt operator -= (const LL& b)     { *this=*this-b; return *this; }


    //Function of Multiply and Division
    BigInt operator * (const BigInt& b) const
    {
        BigInt x=*this;
        BigInt y=b;
        BigInt ans;
        if ((x.Positive && y.Positive) || (!x.Positive && !y.Positive)) ans.Positive=1;
        else ans.Positive=0;
        int m=x.VecNum,n=y.VecNum;
        int L=m+n+1;
        ans.VecNum=L;
        ans.A.resize(L+3);
        Rep(0,m,i)
            Rep(0,n,j)
            {
                int pos=i+j;
                LL t=x.A[i]*y.A[j];
                int post=0;
                while (t>0)
                {
                    ans.A[pos+post]+=t%IntMod;
                    t/=IntMod;
                    post++;
                }
            }
        Rep(0,L,i) { ans.A[i + 1] += ans.A[i] / IntMod; ans.A[i] %= IntMod; }
        while (ans.A[L - 1] == 0 && ((L-1)!=0) ) { ans.VecNum--; ans.A.pop_back(); L--; }
        return ans;
    }
    BigInt operator * (const LL &b) const    { BigInt x(b); return (*this) * x; }
    BigInt operator * (const string b) const { BigInt x(b); return (*this) * x; }
    BigInt operator *= (const BigInt& b){ *this = *this * b; return *this; }
    BigInt operator *= (const LL &b)    { *this = *this * b; return *this; }
    BigInt operator *= (const string b) { *this = *this * b; return *this; }


    //Function of BITS
}f[201];

int main()
{
    LL a=1;
    f[1]=BigInt(1);
    f[2]=BigInt(2);

    for(int i=3;i<=200;i++) f[i]=f[i-1]+f[i-2];
    int n;
    while(scanf("%d",&n)!=EOF) {
        cout<<f[n]<<endl;
    } 

    return 0;
}

Problem D

度熊所居住的 D 国，是一个完全尊重人权的国度。以至于这个国家的所有人命名自己的名字都非常奇怪。一个人的名字由若干个字符组成，同样的，这些字符的全排列的结果中的每一个字符串，也都是这个人的名字。例如，如果一个人名字是 ACM，那么 AMC， CAM， MAC， MCA， 等也都是这个人的名字。在这个国家中，没有两个名字相同的人。

度熊想统计这个国家的人口数量，请帮助度熊设计一个程序，用来统计每一个人在之前被统计过多少次。

这里包括一组测试数据，第一行包含一个正整数NNN，接下来的NNN 行代表了 NNN 个名字。NNN 不会超过100,000100,000100,000，他们的名字不会超过40位.

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<iostream>
#include<cmath>
#include<string>
#include<map>
#include<cctype>
#include<ctime>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=pre[x];p;p=next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=next[p])  
#define Lson (x<<1)
#define Rson ((x<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define fi first
#define se second
typedef long long ll;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
map<string,int> h;
map<string,int>::iterator it;

string s;
int main()
{
//  freopen("d.in","r",stdin);
//  freopen(".out","w",stdout);

    int n;
    scanf("%d",&n);
    For(i,n) {
        cin>>s;
        sort(s.begin(),s.end());
        it=h.find(s);
        if (it==h.end()){
            h[s]=1;
            puts("0");
        }else {
            printf("%d\n",(it->se)++);

        }
    }

    return 0;
}
nike0good
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU5658-Problem B(斐波拉契数列)
weixin_43357583的博客
05-12 160
度熊面前有一个全是由1构成的字符串，被称为全1序列。你可以合并任意相邻的两个1，从而形成一个新的序列。对于给定的一个全1序列，请计算根据以上方法，可以构成多少种不同的序列。 Input 这里包括多组测试数据，每组测试数据包含一个正整数N，代表全1序列的长度。 1≤N≤200 Output 对于每组测试数据，输出一个整数，代表由题目中所给定的全1序列所能形成的新序列的数量。 Sample Input 1 3 5 Sample Output 1 3 8 Hint 如果序列是：(111)。可以构造出如下三个新序列
HDU-5685-Problem A（求逆元模板题）
qq_43461168的博客
11-08 400
Problem A Problem Description 度熊手上有一本字典存储了大量的单词，有一次，他把所有单词组成了一个很长很长的字符串。现在麻烦来了，他忘记了原来的字符串都是什么，神奇的是他竟然记得原来那些字符串的哈希值。一个字符串的哈希值，由以下公式计算得到： H(s)=∏i≤len(s)i=1(Si−28) (mod 9973) Si代表 S[i] 字符的 ASCII 码。 请帮助度熊...
百度之星2014-2016资格赛试题及解答
仰望星空
07-05 4913
百度之星2014-2016资格赛试题、解答及代码实现
bestcoder 2016百度之星资格赛 1001 （逆元）
大太阳
05-14 788
http://bestcoder.hdu.edu.cn/contests/contest_showproblem.php?cid=690&pid=1001 度熊手上有一本字典存储了大量的单词，有一次，他把所有单词组成了一个很长很长的字符串。现在麻烦来了，他忘记了原来的字符串都是什么，神奇的是他竟然记得原来那些字符串的哈希值。一个字符串的哈希值，由以下公式计算得到： H(s)=\pr
度熊的哈希
Donald_TY的专栏
07-14 463
题目描述 度熊手上有一本字典存储了大量的单词，有一次，他把所有单词组成了一个很长很长的字符串。现在麻烦来了，他忘记了原来的字符串都是什么，神奇的是他竟然记得原来那些字符串的哈希值。一个字符串的哈希值，由以下公式计算得到：H(s)=∏(Si−28)(mod9973)H(s)=∏ (Si−28) (mod 9973) Si代表S[i]字符的ASCII码,∏代表连乘，1<=i<=len(s)Si代表
混合A星算法-Hybrid_Astar（matlab）
12-02
混合A星算法（Hybrid A*）是一种在路径规划领域广泛应用的智能搜索算法，它结合了经典的A*算法和其它优化策略，以提高路径搜索效率和质量。在本项目中，混合A*算法被用于车辆的路径规划，利用车辆的运动学模型来定义...
Astar2007百度之星程序设计大赛网络资格赛（初赛） 题
11-06
根据给定的信息，我们可以分析出这是关于Astar2007百度之星程序设计大赛网络资格赛（初赛）的相关题目及解析。以下是对各题目所涉及的知识点进行详细阐述： ### 第一题：时间线问题 #### 题目描述： 本题要求处理...
Go-go-astar-A星路径搜索算法的Go实现
08-14
A星(A*)路径搜索算法是一种在图形中寻找从起点到终点最短路径的高效搜索算法。它结合了最佳优先搜索和Dijkstra算法的优点，通过引入启发式函数来预测每个节点到达目标的潜在代价，从而减少了搜索空间，提高了效率。...
混合A星算法-Hybrid-Astar（matlab）.zip
最新发布
12-05
1. `main.m`：主程序文件，用于调用混合A*算法，设置参数，初始化地图和目标位置。 2. `astar.m`：A*算法的核心实现，包括节点扩展、代价评估、开放列表和关闭列表的管理等。 3. `heuristic.m`：启发式函数的定义，...
Robot-Path-planning-AStar:使用A-star算法的机器人路径规划
05-11
Robot-Path-planning-AStar Robot path planning using A* algorithm 扫地机器人自动寻路实现（使用A*算法） 地图实例(Sample map of room)： *#_* _*__ _#_@ It shows that in a room with 3 rows and 4 columns...
百度之星资格赛代码（不完全版）
06-04
百度之星资格赛代码，我OJ了7道吧大约。
2016"百度之星" - 资格赛(Astar Round1)-(模拟+线段树+乘法逆元)
qq_18661257的专栏
05-15 3608
Problem A    Accepts: 1351    Submissions: 9951  Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Problem Description 度熊手上有一本字典存储了大量的单词，有一次，他把
HDU 1715 大斐波拉契数
第一楼主的博客
06-11 310
Problem DescriptionFibonacci数列，定义如下：f(1)=f(2)=1f(n)=f(n-1)+f(n-2) n&gt;=3。计算第n项Fibonacci数值。 Input输入第一行为一个整数N，接下来N行为整数Pi（1&lt;=Pi&lt;=1000）。 Output输出为N行，每行为对应的f(Pi)。 Sample Input5 1 2 3 4 5 Sample Outp...
hdoj 1865 1sting 【大数斐波那契】
R
05-21 464
1sting Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4763    Accepted Submission(s): 1784 Problem Description You will be given a
2016百度之星资格赛 B题
Mxianyi的专栏
05-18 386
Problem B Accepts: 2288 Submissions: 8466 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Problem Description 度熊面前有一个全是由1构成的字符串，被称为全1序列。你可以合并任意相邻的两
2016"百度之星" - 资格赛（Astar Round1） C
I good vegetable a!
05-14 684
Problem Description 度熊手上有一本神奇的字典，你可以在它里面做如下三个操作： 1、insert : 往神奇字典中插入一个单词 2、delete: 在神奇字典中删除所有前缀等于给定字符串的单词 3、search: 查询是否在神奇字典中有一个字符串的前缀等于给定的字符串 Input 这里仅有一组测试数据。第一行输入一个正整数N(1≤N≤100000
HDU5685 (费马小定理,逆元)
nka_kun的博客
11-08 454
Problem ATime Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 1537    Accepted Submission(s): 691Problem Description度熊手上有一本字典存储了大量的单词，有一次，他把所有单词组成了一个...
大数加法 + 斐波那契数列
qq_37410469的博客
08-28 1637
Problem Description 度熊面前有一个全是由1构成的字符串，被称为全1序列。你可以合并任意相邻的两个1，从而形成一个新的序列。对于给定的一个全1序列，请计算根据以上方法，可以构成多少种不同的序列。 Input 这里包括多组测试数据，每组测试数据包含一个正整数N，代表全1序列的长度。 1≤N≤200 Output 对于每组测试数据，输出一个整数，代表由题目中所给定
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值