长乐培训Day2

T1 足球联赛

题目

【题目描述】

巴蜀中学新一季的足球联赛开幕了。足球联赛有n只球队参赛，每赛季，每只球队要与其他球队各赛两场，主客各一场，赢一场得3分，输一场不得分，平局两只队伍各得一分。

英勇无畏的小鸿是机房的主力前锋，她总能在关键时刻踢出一些匪夷所思的妙球。但是很可惜，她过早的燃烧完了她的职业生涯，不过作为一个能够Burning的girl，

她的能力不止如此，她还能预测这个赛季所有球队的比赛结果。虽然她能准确预测所有比赛的结果，但是其实她不怎么厉害，Mr.Gao上数学课时她总是在sleep，因此她的脑里只有整数没有实数，

而且，她只会10以内非负整数的加法运算，因此她只有结果却无法知道谁会获得联赛的冠军。

小鸿想给冠军队伍的所有队员一个拥抱，所以她把计算结果的任务交给了你：

现在，给你一个 n*n 的矩阵表示比赛情况。第 i 行第 j 列的字母表示在第 i 只队伍在主场迎战第j只队伍的比赛情况，W 表示主队赢，L 表示主队输，D 表示平局。

现在需要你给出最后能得到小鸿拥抱的队伍编号，如有多支队伍分数最高，按字典序输出编号。

【输入格式】

第一行一个整数 n。

接下来 n 行,每行 n 个字符，表示输赢情况。

第 i 行第 i 列为 - ,因为一只队伍不可能与自己比赛。

【输出格式】

输出得分最高的队伍编号。如有多个在一行中输出，用一个空格分开。

【输入样例】

-WW

W-W

WW-

【输出样例】

1 2 3

【数据规模】

对于40%的数据，满足N<=20

对于100%的数据，满足N<=50

解析

纯模拟题，直接模拟就行了，没什么好说的，就是输出时要记得判断最高成绩相同的都要输出。

Code

#include <algorithm>

#include <iostream>

#include <cstring>

#include <string>

#include <cstdio>

#include <cmath>

using namespace std;

int read()

{

    int num=,w=;

    char ch=getchar();

    while(ch<''||ch>'')

    {

        if(ch=='-') w=-;

        ch=getchar();

    }

    while(ch>=''&&ch<='')

    {

        num=(num<<)+(num<<)+ch-'';

        ch=getchar();

    }

    return num*w;

}

int n,ans[],maxn,temp,ra[];

char s;

int main()

{

    //freopen("soccer.in","r",stdin);

    //freopen("soccer.out","w",stdout);

    n=read();

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

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

        {

            cin>>s;

            if(s=='W') ans[i]+=;

            else if(s=='L') ans[j]+=;

            else if(s=='D')

            {

                ans[i]+=;

                ans[j]+=;

            }

        }

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

        if(ans[i]>maxn)

        {

            maxn=ans[i];

            temp=;

            ra[temp]=i;

        }

        else if(ans[i]==maxn) ra[++temp]=i;

    for(int i=;i<=temp;i++) cout<<ra[i]<<" ";

    return ;

    //fclose(stdin);

    //fclose(stdout);

}

T2 生产

题目

【题目描述】

工厂为了生产一种复杂的产品，给各个生产部门制定了详细的生产计划。那么，就经常会有生产部门要把产品送到另一个生产部门作为原料。

这是一个注重产品质量的工厂，所以每当有产品要从A部门运到B部门时，都要先从A部门送到质量检验处，检验合格后再从质量检验处运到B部门。

有些部门之间有传送带连接，厂长想知道每次将产品从一个部门运送到另一个部门最少需要多长时间。

【输入格式】

第一行两个整数n、m，n表示部门数量，m表示传送带数量。出于方便，1号部门是质量检验处。

接下来m行，每行三个整数u、v、w，表示有一条从u部门到v部门的传送带，传送过去需要w个单位时间。注意传送带是单向的。

接下来一个整数q，表示有q次运送。

接下来q行，每行两个数a、b，表示这一次要将产品从a部门运送到b部门。

【输出格式】

输出q行，每行一个整数，表示这次运送最少需要的时间。若没有传送方案，输出-1。

【输入样例】

5 5

1 2 3

1 3 5

4 1 7

5 4 1

5 3 1

4 2

5 3

2 3

【输出样例】

-1

【数据规模】

30%的数据，n≤100，m≤500，w=1

60%的数据，n≤100，m≤5000

另20%的数据，q=1

100%的数据，2≤n≤3000，m≤100000，2≤a,b≤n，

q≤100000，1≤u,v≤n，1≤w≤10000

有些部门之间可能有多条传送带。

工厂的员工都非常尽职尽责，他们的认真和热情决定了产品的完美，所以不必考虑产品不合格的情况。

解析

很容易看得出来这题是最短路，只不过是两条最短路：

一条是从a到1，另一条是从1到b，只需要做两遍最短路即可。

最短路推荐用dijkstra，如果用SPFA的话数据大一点、出题人卡一下就炸了。

Code

#include <algorithm>

#include <iostream>

#include <cstring>

#include <string>

#include <cstdio>

#include <cmath>

#include <queue>

using namespace std;

int read()

{

    int num=,w=;

    char ch=getchar();

    while(ch<''||ch>'')

    {

        if(ch=='-') w=-;

        ch=getchar();

    }

    while(ch>=''&&ch<='')

    {

        num=(num<<)+(num<<)+ch-'';

        ch=getchar();

    }

    return num*w;

}

const int N=;

const int M=;

priority_queue< pair<int,int> > q;

int n,m,qq,tot1,tot2,head1[N],ver1[M],edge1[M],next1[M],head2[N],ver2[M],edge2[M],next2[M];

long long d1[N],d2[N];

bool vist[N];

void add1(int x,int y,int z)

{

    ver1[++tot1]=y;

    edge1[tot1]=z;

    next1[tot1]=head1[x];

    head1[x]=tot1;

}

void add2(int x,int y,int z)

{

    ver2[++tot2]=y;

    edge2[tot2]=z;

    next2[tot2]=head2[x];

    head2[x]=tot2;

}

void dijkstra1()

{

    memset(d1,0x7f7f7f7f,sizeof(d1));

    memset(vist,false,sizeof(vist));

    d1[]=;

    q.push(make_pair(,));

    while(q.size())

    {

        int x=q.top().second;

        q.pop();

        if(vist[x]) continue;

        vist[x]=true;

        for(int i=head1[x];i;i=next1[i])

        {

            int y=ver1[i],z=edge1[i];

            if(d1[y]>d1[x]+z)

            {

                d1[y]=d1[x]+z;

                q.push(make_pair(-d1[y],y));

            }

        }

    }

}

void dijkstra2()

{

    memset(d2,0x7f7f7f7f,sizeof(d2));

    memset(vist,false,sizeof(vist));

    d2[]=;

    q.push(make_pair(,));

    while(q.size())

    {

        int x=q.top().second;

        q.pop();

        if(vist[x]) continue;

        vist[x]=true;

        for(int i=head2[x];i;i=next2[i])

        {

            int y=ver2[i],z=edge2[i];

            if(d2[y]>d2[x]+z)

            {

                d2[y]=d2[x]+z;

                q.push(make_pair(-d2[y],y));

            }

        }

    }

}

int main()

{

    //freopen("production.in","r",stdin);

    //freopen("production.out","w",stdout);

    int u,v,w,a,b;

    n=read(),m=read();

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

    {

        u=read(),v=read(),w=read();

        add1(u,v,w);

        add2(v,u,w);

    }

    dijkstra1();

    dijkstra2();

    qq=read();

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

    {

        a=read(),b=read();

        if(d2[a]>=0x3f3f3f3f||d1[b]>=0x3f3f3f3f) cout<<"-1"<<endl;

        else cout<<d2[a]+d1[b]<<endl;

    }

    return ;

    //fclose(stdin);

    //fclose(stdout);

}

T3 最短路径

题目

【题目描述】

平面内给出 n 个点，记横坐标最小的点为 A，最大的点为 B，现在小Y想要知道在每个点经过一次（A 点两次）的情况下从 A 走到 B，再回到 A 的最短路径。

但他是个强迫症患者，他有许多奇奇怪怪的要求与限制条件：

1.从 A 走到 B 时，只能由横坐标小的点走到大的点。

2.由 B 回到 A 时，只能由横坐标大的点走到小的点。

3.有两个特殊点 b1 和 b2， b1 在 0 到 n-1 的路上，b2 在 n-1 到 0 的路上。

请你帮他解决这个问题助他治疗吧！

【输入格式】

第一行三个整数 n,b1,b2,( 0 < b1，b2 < n-1 且 b1 ≠ b2)。n 表示点数，从 0 到 n-1 编号，b1 和 b2 为两个特殊点的编号。

以下 n 行，每行两个整数 x、y 表示该点的坐标(0 <= x，y <= 2000)，从 0 号点顺序给出。Doctor Gao为了方便他的治疗，已经将给出的点按 x 增序排好了。

【输出格式】

输出仅一行，即最短路径长度（精确到小数点后面 2 位）

【输入样例】

5 1 3

1 3

3 4

4 1

7 5

8 3

【输出样例】

18.18

【数据规模】

20%的数据n<=20

60%的数据n<=300

100%的数据n<=1000

解析

这道题本蒟蒻做的时候写了个暴力，果不其然，TLE...

后来才知道原来这题是DP。

他是从A走到B再走回A，所以我们可以将问题转化为求两条和最小的不相交线段。

令f[i][j]表示从A到B的线段走到了i点，从B到A的线段走到了j点。

边界为：f[0][0]=0。

状态转移方程：（k=max(i,j)）

k!=n-1时，

1、f[i][k]=min(f[i][k],f[i][j]+d(j,k));（k!=b1）

2、f[k][j]=min(f[k][j],f[i][j]+d(i,k));（k!=b2）

k==n-1时，

3、f[n-1][n-1]=min(f[n-1][n-1],f[i][n-1]+d(i,n-1));（i!=n-1）

4、f[n-1][n-1]=min(f[n-1][n-1],f[n-1][j]+d(j,n-1));（j!=n-1）

PS:由于是从0开始编号，所以最后一个点为n-1，当然，也可以全部+1从1开始编号（会更美观），主要看个人喜好。

Code

#include <algorithm>

#include <iostream>

#include <cstring>

#include <string>

#include <cstdio>

#include <cmath>

#include <queue>

using namespace std;

int read()

{

    int num=,w=;

    char ch=getchar();

    while(ch<''||ch>'')

    {

        if(ch=='-') w=-;

        ch=getchar();

    }

    while(ch>=''&&ch<='')

    {

        num=(num<<)+(num<<)+ch-'';

        ch=getchar();

    }

    return num*w;

}

const int N=;

int n,b1,b2,k;

double f[N][N],x[N],y[N];

double d(int i,int j)

{

    return sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));

}

int main()

{

    //freopen("paths.in","r",stdin);

    //freopen("paths.out","w",stdout);

    memset(f,0x7f7f7f7f,sizeof(f));

    f[][]=;

    n=read(),b1=read(),b2=read();

    for(int i=;i<n;i++) x[i]=read(),y[i]=read();

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

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

        {

            k=max(i,j);

            if(k!=n-)

            {

                k++;

                if(k!=b1) f[i][k]=min(f[i][k],f[i][j]+d(j,k));

                if(k!=b2) f[k][j]=min(f[k][j],f[i][j]+d(i,k));

            }

            else

            {

                if(i!=n-) f[n-][n-]=min(f[n-][n-],f[i][n-]+d(i,n-));

                if(j!=n-) f[n-][n-]=min(f[n-][n-],f[n-][j]+d(j,n-));

            }

        }

    printf("%.2lf",f[n-][n-]);

    return ;

    //fclose(stdin);

    //fclose(stdout);

}

T4 简单的序列

题目

【题目描述】

从前有个括号序列s，满足|s|=m。你需要统计括号序列对(p,q)的数量。

其中(p,q)满足|p|+|s|+|q|=n，且p+s+q是一个合法的括号序列。

【输入格式】

第一行两个正整数n,m。

第二行一个长度为m的括号序列，表示s。

【输出格式】

输出一行一个整数，表示符合条件的(p,q)的数量对10^9+7取模的值。

【输入样例】

4 1

(

【输出样例】

【数据规模】

对于10%的数据，n≤20；

对于25%的数据，n≤200；

对于另外5%的数据，n=m；

对于55%的数据，n-m≤200；

对于100%的数据，1≤m≤n≤10^5，n-m≤2000。

解析

这题有点意思，其实是一道DP题。

将'('转换为1，')'转换为-1。

令f[i][j]表示前i个括号总值为j（边界：f[0][0]=f[1][1]=1）。

而这里的j是一定不为负数的。为什么？因为若j为负数，就意味着当前右括号比左括号多，

这种情况即使后面加入左括号，就会变成“)(”这种情况，即右括号在左，左括号在右，很显然是不合法的。

所以初始赋值时，令f[i][0]=f[i-1][1]，因为如果是f[i][0]=f[i-1][-1]的话就成了上面说的情况，不合法。

梳理了这么多，可以轻易推出状态转移方程：

1、f[i][j]=f[i-1][j-1]（添加左括号）。

2、f[i][j]=f[i-1][j+1]（添加右括号）。

Code

#include <algorithm>

#include <iostream>

#include <cstring>

#include <string>

#include <cstdio>

#include <cmath>

#include <queue>

using namespace std;

int read()

{

    int num=,w=;

    char ch=getchar();

    while(ch<''||ch>'')

    {

        if(ch=='-') w=-;

        ch=getchar();

    }

    while(ch>=''&&ch<='')

    {

        num=(num<<)+(num<<)+ch-'';

        ch=getchar();

    }

    return num*w;

}

const long long mod=;

int n,m,temp,a[],minn=0x7f7f7f7f,ans;

long long f[][];

char s;

int main()

{

    //freopen("bracket.in","r",stdin);

    //freopen("bracket.out","w",stdout);

    n=read(),m=read();

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

    {

        cin>>s;

        if(s=='(') a[++temp]=;

        else a[++temp]=-;

    }

    f[][]=f[][]=;

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

    {

        f[i][]=f[i-][];

        for(int j=;j<=n-m;j++) f[i][j]=(f[i-][j-]+f[i-][j+])%mod;

    }

    temp=;

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

    {

        temp+=a[i];

        minn=min(minn,temp);

    }

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

        for(int j=-minn;j<=i;j++)

        {

            int l=n-m-i,b=temp+j;

            if(b>=) ans=(long long)(f[l][b]*f[i][j]+ans)%mod;

        }

    cout<<ans;

    return ;

    //fclose(stdin);

    //fclose(stdout);

}