[SinGuLaRiTy] 2017 百度之星程序设计大赛复赛

Arithmetic of Bomb

Problem Description

众所周知，度度熊非常喜欢数字。

它最近在学习小学算术，第一次发现这个世界上居然存在两位数，三位数……甚至N位数！

但是这回的算术题可并不简单，由于含有表示bomb的#号，度度熊称之为 Arithmetic of Bomb。

[SinGuLaRiTy] 2017 百度之星程序设计大赛复赛

Bomb Number中的bomb，也就是#号，会展开一些数字，这会导致最终展开的数字超出了度度熊所能理解的范畴。比如”(1)#(3)”表示”1”出现了3次，将会被展开为”111”，

同理，”(12)#(2)4(2)#(3)”将会被展开为”12124222”。

为了方便理解，下面给出了Bomb Number的BNF表示。

```

<bomb term> := <number> | '(' <number> ')' '#' '(' <non-zero-digit> ')'

<digit> := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'

<non-zero-digit> := '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'

```

请将Bomb Number中所有的#号展开，由于数字可能很长，结果对 1 000 000 007 取模。

Input

第一行为T，表示输入数据组数。

每组数据包含一个Bomb Expression。

- 1≤T≤100

- 1≤length(Bomb Number)≤1000

Output

对每组数据输出表达式的结果，结果对 1 000 000 007 取模。

Sample Input

(1)#(3)

(12)#(2)4(2)#(3)

(12)#(5)

Sample Output

111

12124222

212121205

Code

模拟，签到题不解释。

#include<cstdio>

#include<cstring>

#include<cctype>

#include<cmath>

#include<algorithm>

#define ll long long

#define inf 0x3f3f3f3f

#define maxn 101000

#define MOD 1000000007

using namespace std;

int read()

{

    char c;int s=,t=;

    while(!isdigit(c=getchar()))if(c=='-')t=-;

    do{s=s*+c-'';}while(isdigit(c=getchar()));

    return s*t;

}

int n;

char s[maxn],ans[maxn],nows[maxn];

int main()

{

    int T;

    scanf("%d",&T);

    while(T--)

    {

        scanf("%s",s+);

        int n=strlen(s+);

        int nowstep=,len=,tot=;

        for(int i=;i<=n;i++)if(isdigit(s[i]))

        {

            if(nowstep==){nows[++len]=s[i];}

            else

                if(nowstep==)

                {

                    for(int j=;j<=s[i]-'';j++)

                        for(int k=;k<=len;k++)

                            ans[++tot]=nows[k];

                    len=;nowstep=;

                }

                else

                    if(nowstep==)ans[++tot]=s[i];

        }

        else

        {

            if(nowstep==&&s[i]=='(')

                nowstep=;

            else if(nowstep==&&s[i]==')')

                nowstep=;

        }

        long long ansnum=;

        for(int i=;i<=tot;i++)

            ansnum=(ansnum*+ans[i]-'')%MOD;

        printf("%lld\n",ansnum);

    }

    return ;

}

Arithmetic of Bomb II

Problem Descroption

众所周知，度度熊非常喜欢数字。
它最近在学习小学算术，沉迷于计算A+B中不能自拔。
但是这回的算术题可并不简单，由于含有表示bomb的#号，度度熊称之为 Arithmetic of Bomb。

[SinGuLaRiTy] 2017 百度之星程序设计大赛复赛

Arithmetic of Bomb的目的与普通算术一样，就是计算一些Bomb Expression的结果。比如，”1-2+3”的结果为2。然而，bomb，也就是#号，会展开一些普通表达式，这会导致需要计算的式子超出了度度熊所能理解的范畴。比如”(1-2+3)#(3)”表示”1-2+3”出现了3次，将会被展开为”1-2+31-2+31-2+3”。
为了方便理解，下面给出了Bomb Expression的BNF表示。
```
<bomb expression> := <bomb term> | <bomb expression> <bomb term>
<bomb term> := <bomb statement> | '(' <bomb statement> ')' '#' '(' <number> ')'
<bomb statement> := <bomb element> | <bomb statement> <bomb element>
<bomb element> := <digit> | '+' | '-' | '*'
<normal expression> := <norm term> | <normal expression> '+' <norm term> | <normal expression> '-' <norm term>
<norm term> := <number> | <norm term> '*' <number>
<number> := <digit> | <non-zero-digit> <number>
<digit> := '0' | <non-zero-digit>
<non-zero-digit> := '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
```
请先将Bomb Expression中所有的#号展开，使其成为Normal Expression（题目的输入保证展开后是一个合法的Normal Expression），再来计算这个表达式的结果。

Input

第一行为T，表示输入数据组数。
每组数据包含一个Bomb Expression。
●1≤T≤50
●1≤length(Bomb Statement)≤10
●1≤length(Number in Bomb term)≤10
●1≤length(Bomb Expression)≤300 000

Output

对每组数据输出表达式的结果，结果对 1 000 000 007 取模。

Sample Input

6
1-2+3
(1-2+3)#(3)
(1)#(3)
(1+)#(2)1
(2*3+1)#(2)
(2)#(2)1+1(2)#(2)

Sample Output

2
60
111
3
43
343

Code

我还不会矩阵运算呀，只好先在这里放一放大牛的代码了（能做出这道题的确佩服！）

【本题题解来自于：y5zsq】

[SinGuLaRiTy] 2017 百度之星程序设计大赛复赛

Code

#include<cstdio>

#include<iostream>

#include<cstring>

#include<algorithm>

#include<cmath>

#include<vector>

#include<queue>

using namespace std;

typedef long long ll;

#define maxn 300005

#define mod 1000000007

vector<string>term;

vector<ll>num;

char c[maxn];

int T;

void Deal()

{

    term.clear(),num.clear();

    int n=strlen(c);

    for(int i=;i<n;)

    {

        string s;

        if(c[i]=='(')

        {

            i++;

            while(c[i]!=')')s.push_back(c[i++]);

            i+=;

            ll t=;

            while(c[i]!=')')t=t*+c[i++]-'';

            if(t)term.push_back(s),num.push_back(t);

            i++;

        }

        else

        {

            while(i<n&&c[i]!='(')s.push_back(c[i++]);

            term.push_back(s),num.push_back();

        }

    }

}

typedef ll Mat[][];

Mat A,B,C;

void Mul(Mat &a,Mat b)

{

    Mat c;

    for(int i=;i<;i++)

        for(int j=;j<;j++)

        {

            c[i][j]=;

            for(int k=;k<;k++)

                c[i][j]+=a[i][k]*b[k][j];

        }

    for(int i=;i<;i++)

        for(int j=;j<;j++)

            a[i][j]=(c[i][j]%mod+mod)%mod;

}

void Pow(Mat &a,ll b)

{

    if(b==)return ;

    Mat c;

    for(int i=;i<;i++)

        for(int j=;j<;j++)

            c[i][j]=(i==j);

    while(b)

    {

        if(b&)Mul(c,a);

        Mul(a,a);

        b>>=;

    }

    for(int i=;i<;i++)

        for(int j=;j<;j++)

            a[i][j]=c[i][j];

}

ll Count()

{

    for(int i=;i<;i++)

        for(int j=;j<;j++)

            A[i][j]=(i==j);

    int sign=;

    for(int k=;k<term.size();k++)

    {

        string s=term[k];

        ll t=num[k];

        int n=s.size();

        for(int i=;i<;i++)

            for(int j=;j<;j++)

                B[i][j]=(i==j);

        for(int i=;i<n;i++)

        {

            memset(C,,sizeof(C));

            C[][]=C[][]=;

            if(s[i]>=''&&s[i]<='')

                C[][]=,C[][]=s[i]-'',C[][]=;

            else if(s[i]=='+')

                C[][]=sign,C[][]=,sign=;

            else if(s[i]=='-')

                C[][]=sign,C[][]=,sign=-;

            else C[][]=;

            Mul(B,C);

        }

        Mul(A,B);

        if(t>)

        {

            for(int i=;i<;i++)

                for(int j=;j<;j++)

                    B[i][j]=(i==j);

            for(int i=;i<n;i++)

            {

                memset(C,,sizeof(C));

                C[][]=C[][]=;

                if(s[i]>=''&&s[i]<='')

                    C[][]=,C[][]=s[i]-'',C[][]=;

                else if(s[i]=='+')

                    C[][]=sign,C[][]=,sign=;

                else if(s[i]=='-')

                    C[][]=sign,C[][]=,sign=-;

                else C[][]=;

                Mul(B,C);

            }

            Pow(B,t-);

            Mul(A,B);

        }

    }

    ll ans=(A[][]+A[][])%mod;

    if(sign==)ans=(ans+A[][]+A[][])%mod;

    else ans=(ans-A[][]-A[][])%mod;

    ans=(ans+mod)%mod;

    return ans;

}

int main()

{

    scanf("%d",&T);

    while(T--)

    {

        scanf("%s",c);

        Deal();

        printf("%I64d\n",Count());

    }

    return ;

}

Pokémon GO

Problem Description

众所周知，度度熊最近沉迷于 Pokémon GO。

[SinGuLaRiTy] 2017 百度之星程序设计大赛复赛

今天它决定要抓住所有的精灵球！
为了不让度度熊失望，精灵球已经被事先放置在一个2*N的格子上，每一个格子上都有一个精灵球。度度熊可以选择任意一个格子开始游戏，抓捕格子上的精灵球，然后移动到一个相邻的至少有一个公共点的格子上继续抓捕。例如，(2, 2) 的相邻格子有(1, 1), (2, 1) 和 (1, 2) 等等。
现在度度熊希望知道将所有精灵球都抓到并且步数最少的方案数目。两个方案被认为是不同，当且仅当两个方案至少有一步所在的格子是不同的。

Input

第一行为T，表示输入数据组数。
每组数据包含一个数N。
●1≤T≤100
●1≤N≤10000

Output

对每组数据输出方案数目，结果对 1 000 000 007 取模。

Sample Input

3
1
2
3

Sample Input

2
24
96

Code

动态规划

#include<cstdio>

#include<cmath>

#include<cstdlib>

#include<algorithm>

#include<iostream>

#include<cstring>

#define ll long long

const int maxn=,MOD=;

ll a[maxn],b[maxn],n;

int main()

{

    b[]=;

    for(int i=;i<=maxn;i++)

        b[i]=(b[i-]*)%MOD;

    a[]=;

    a[]=;

    for(int i=;i<=maxn;i++)

        a[i]=(*a[i-]+b[i]+*a[i-])%MOD;

    int T;

    scanf("%d",&T);

    while(T--)

    {

        int n;

        scanf("%d",&n);

        ll ans=;

        for(int i=;i<=n-;i++)

            ans=(ans+*b[i-]%MOD*a[n-i])%MOD;

        ans=(ans+*a[n])%MOD;

        if(n==)

            ans=;

        printf("%lld\n",ans);

    }

    return ;

}

Pokémon GO II

Problem Description

众所周知，度度熊最近沉迷于 Pokémon GO。

[SinGuLaRiTy] 2017 百度之星程序设计大赛复赛

由于太过沉迷，现在它只能按照游戏内置的指令行走了：对，简直就像一个现实中的Pokémon！
游戏内置的指令实际上可以抽象成一种：保持现在的朝向前行X米，然后右转。度度熊相信，只要遵循这个指令，它就一定可以抓到最珍奇的精灵球。
但不幸的是，这个指令并不是很有可信度，有时会引导度度熊走回原来的位置。现在它想知道，在第几条指令时它第一次回到已经走过的位置？如果这种情况没有发生，请输出 “Catch you”。

Input

第一行为T，表示输入数据组数。
每组数据的第一行包含一个数N，表示指令长度。接着的一行包含N个数字Xi，表示第i个指令中前行的距离。
● 1≤T≤100
● 1≤N≤1 000 000
● 1≤Xi≤1 000 000 000

Output

对每组数据输出第一次回到已经走过的位置时的指令下标i (1≤i≤N)。
如果这种情况没有发生，请输出 “Catch you”。

Sample Input

3
4
2 2 2 2
4
2 1 3 1
5
2 1 3 1 3

Sample Output

4
Catch you
5

Code

目测几何神犇题，发现可以画画图找规律......第一次覆盖一定发生在轨迹的前8段中。

#include<cstdio>

#include<algorithm>

#include<cstdlib>

#include<cmath>

#include<iostream>

#include<cstdlib>

#define MAXN 1000010

using namespace std;

const int dx[]={,,,-},dy[]={,,-,};

int N,a[MAXN];

struct Point

{

    int x,y;

    Point(int _x=,int _y=):x(_x),y(_y){}

}points[MAXN];

bool overlap(int a,int b,int c,int d)

{

    if(a>b)

        swap(a, b);

    if(c>d)

        swap(c, d);

    return !(b<c||d<a);

}

bool intersect(Point a1,Point a2,Point b1,Point b2)

{

    bool is_vertical_a=(a1.x==a2.x),is_vertical_b=(b1.x==b2.x);

    if(is_vertical_a && is_vertical_b)

        return a1.x==b1.x&&overlap(a1.y,a2.y,b1.y,b2.y);

    if(!is_vertical_a && !is_vertical_b)

        return a1.y==b1.y&&overlap(a1.x,a2.x,b1.x,b2.x);

    if(is_vertical_a)

    {

        swap(a1,b1);

        swap(a2,b2);

    }

    return !(max(a1.x,a2.x)<b1.x||min(a1.x,a2.x)>b1.x||max(b1.y,b2.y)<a1.y||min(b1.y,b2.y)>a1.y);

}

int solve()

{

    int x=,y=;

    for(int i=;i<N;++i)

    {

        x+=dx[i&]*a[i];

        y+=dy[i&]*a[i];

        points[i+].x=x;

        points[i+].y=y;

        for(int j=max(,i-);j<i-;++j)

            if(intersect(points[j],points[j+],points[i],points[i+]))

                return i;

    }

    return -;

}

int main()

{

    int T;

    scanf("%d", &T);

    while(T--)

    {

        scanf("%d",&N);

        for(int i=;i<N;++i)

            scanf("%d",a+i);

        int result=solve();

        if(result==-)

            printf("Catch you\n");

        else

            printf("%d\n", result+);

    }

    return ;

}

Valley Numer

Problem Description

众所周知，度度熊非常喜欢数字。
它最近发明了一种新的数字：Valley Number，像山谷一样的数字。

[SinGuLaRiTy] 2017 百度之星程序设计大赛复赛

当一个数字，从左到右依次看过去数字没有出现先递增接着递减的“山峰”现象，就被称作 Valley Number。它可以递增，也可以递减，还可以先递减再递增。在递增或递减的过程中可以出现相等的情况。
比如，1，10，12，212，32122都是 Valley Number。
121，12331，21212则不是。
度度熊想知道不大于N的Valley Number数有多少。
注意，前导0是不合法的。

Input

第一行为T，表示输入数据组数。
每组数据包含一个数N。
● 1≤T≤200
● 1≤length(N)≤100

Output

对每组数据输出不大于N的Valley Number个数，结果对 1 000 000 007 取模。

Sample Input

3
3
14
120

Sample Input

119

Code

记忆化搜索/数位DP

#include<cstdio>

#include<algorithm>

#include<cstring>

#include<cctype>

#define ll long long

using namespace std;

const ll maxn=,MOD=;

ll f[maxn][][],a[maxn],n;

char s[maxn];

ll dfs(ll pos,ll state,ll limit,ll pre)

{

    if(pos==-)

    {

        if(~pre)

            return ;

        else

            return ;

    }

    if(!limit&&~pre&&~f[pos][state][pre])

        return f[pos][state][pre];

    ll up=limit?a[pos]:;

    ll ans=;

    for(int i=;i<=up;i++)

    {

        if(pre==-&&i==)

            ans=(ans+dfs(pos-,state,limit&&i==up,pre))%MOD;

        else if(pre==-&&i!=)

            ans=(ans+dfs(pos-,state,limit&&i==up,i))%MOD;

        else if(state==)

            ans=(ans+dfs(pos-,i>pre,limit&&i==up,i))%MOD;

        else if(state==&&i>=pre)

            ans=(ans+dfs(pos-,state,limit&&i==up,i))%MOD;

    }

    if(!limit&&~pre)

        f[pos][state][pre]=ans;

    return ans;

}

int main()

{

    ll T;

    scanf("%lld",&T);

    memset(f,-,sizeof(f));

    while(T--)

    {

        scanf("%s",s+);

        n=strlen(s+);

        for(int i=;i<=n;i++)

            a[n-i]=s[i]-'';

        printf("%lld\n",dfs(n-,,,-));

    }

    return ;

}

Valley Numer II

Problem Description

众所周知，度度熊非常喜欢图。
它最近发现了图中也是可以出现 valley —— 山谷的，像下面这张图。

[SinGuLaRiTy] 2017 百度之星程序设计大赛复赛

为了形成山谷，首先要将一个图的顶点标记为高点或者低点。标记完成后如果一个顶点三元组<X, Y, Z>中，X和Y之间有边，Y与Z之间也有边，同时X和Z是高点，Y是低点，那么它们就构成一个valley。
度度熊想知道一个无向图中最多可以构成多少个valley，一个顶点最多只能出现在一个valley中。

Input

第一行为T，表示输入数据组数。
每组数据的第一行包含三个整数N，M，K，分别表示顶点个数，边的个数，标记为高点的顶点个数。
接着的M行，每行包含两个两个整数Xi，Yi，表示一条无向边。
最后一行包含K个整数Vi，表示这些点被标记为高点，其他点则都为低点。
● 1≤T≤20
● 1≤N≤30
● 1≤M≤N*(N-1)/2
● 0≤K≤min(N,15)
● 1≤Xi, Yi≤N, Xi!=Yi
● 1≤Vi≤N

Output

对每组数据输出最多能构成的valley数目。

Sample Input

View Sample Input

Sample Output

1
0
2

Code

状压DP

#include<cstdio>

#include<cstring>

#include<cctype>

#include<cmath>

#include<algorithm>

#define ll long long

using namespace std;

int read()

{

    char c;int s=,t=;

    while(!isdigit(c=getchar()))if(c=='-')t=-;

    do{s=s*+c-'';}while(isdigit(c=getchar()));

    return s*t;

}

const int inf=0x3f3f3f3f,maxn=,maxk=;

int n,f[][maxk],c,k,m,hi[maxn];

bool Map[maxn][maxn],high[maxn];

void dfs(int dep,int now,int pre,int cyc,int x)

{

    if(dep==)

        f[now][c]=max(f[now][c],f[pre][cyc]+);

    else

        for(int i=;i<=k-;i++)

            if(Map[x][hi[i+]]&&!(c&(<<i)))

            {

                c|=(<<i);

                dfs(dep+,now,pre,cyc,x);

                c^=(<<i);

            }

}

int main()

{

    int T;

    scanf("%d",&T);

    while(T--)

    {

        n=read();m=read();k=read();

        int u,v;

        memset(Map,,sizeof(Map));

        for(int i=;i<=m;i++)

        {

            u=read();v=read();

            Map[u][v]=Map[v][u]=;

        }

        memset(high,,sizeof(high));

        for(int i=;i<=k;i++)

        {

            u=read();

            high[u]=;

        }

        int nowk=;

        for(int i=;i<=n;i++)if(high[i])hi[++nowk]=i;

        k=nowk;

        memset(f,,sizeof(f));

        int x=;

        for(int i=;i<=n;i++)if(!high[i])

        {

            x=-x;

            memset(f[x],,sizeof(f[x]));

            for(int j=;j<(<<k);j++)

            {

                f[x][j]=max(f[x][j],f[-x][j]);

                c=j;

                dfs(,x,-x,j,i);

            }

        }

        int ans=;

        for(int i=;i<(<<k);i++)ans=max(ans,f[x][i]);

        printf("%d\n",ans);

    }

    return ;

}

Time: 2017-08-24

[SinGuLaRiTy] 2017 百度之星程序设计大赛 复赛

Arithmetic of Bomb

Problem Description

Input

Output

Sample Input

Sample Output

Code

Arithmetic of Bomb II

Problem Descroption

Input

Output

Sample Input

Sample Output

Code

Code

Pokémon GO

Problem Description

Input

Output

Sample Input

Sample Input

Code

Pokémon GO II

Problem Description

Input

Output

Sample Input

Sample Output

Code

Valley Numer

Problem Description

Input

Output

Sample Input

Sample Input

Code

Valley Numer II

Problem Description

Input

Output

Sample Input

Sample Output

Code

相关文章

[SinGuLaRiTy] 2017 百度之星程序设计大赛复赛