集训队日常训练20181124 DIV2

急急忙忙要出去比赛就拉了一场有点sb的题目

5202: 网络寻路

时间限制(普通/Java):1000MS/3000MS 内存限制:65536KByte
总提交: 15 测试通过:12

描述

X 国的一个网络使用若干条线路连接若干个节点。节点间的通信是双向的。某重要数据包，为了安全起见，必须恰好被转发两次到达目的地。该包可能在任意一个节点产生，我们需要知道该网络中一共有多少种不同的转发路径。

源地址和目标地址可以相同，但中间节点必须不同。

如下图所示的网络。

1 -> 2 -> 3 -> 1 是允许的

1 -> 2 -> 1 -> 2 或者 1 -> 2 -> 3 -> 2 都是非法的。

输入

输入数据的第一行为两个整数N M，分别表示节点个数和连接线路的条数(1<=N<=10000; 0<=M<=100000)。

接下去有M行，每行为两个整数 u 和 v，表示节点u 和 v 联通(1<=u,v<=N , u!=v)。

输入数据保证任意两点最多只有一条边连接，并且没有自己连自己的边，即不存在重边和自环。

输出

输出一个整数，表示满足要求的路径条数。

样例输入

3 3
1 2
2 3
1 3

样例输出

提示

样例输入2

4 4
1 2
2 3
3 1
1 4

样例输出2

题目来源

蓝桥杯

可以dfs去枚举，也就是去枚举两边的点让他们不形成环

但是注意目的地可以和源地址相同，那么合法的就有以下两种情况

case1

case2

和当前节点的度有关，即这条边除了这条路带来的度的乘积

#include<bits/stdc++.h>

using namespace std;

const int N=;

int d[N],u[N],v[N],n,m;

int main()

{

    long long ans=;

    scanf("%d%d",&n,&m);

    for(int i=; i<m; i++)scanf("%d%d",&u[i],&v[i]),d[u[i]]++,d[v[i]]++;

    for(int i=; i<m; i++)if(d[u[i]]>&&d[v[i]]>)ans+=(d[u[i]]-)*1LL*(d[v[i]]-)*;

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

    return ;

}

3198: 区间和

时间限制(普通/Java):1000MS/3000MS 内存限制:65536KByte
总提交: 775 测试通过:247

描述

给定n个数据，有两个操作，加减其中的一个数据，当然还可查询在某段数据的和。

输入

输入数据有多组，每组数据的
第一行输入n，1=<n<=500000,代表数据的个数。
第二行输入具体数据，数据为正整数，范围在1到10000.
第三行输入m，1<=m<=100000,表示操作的次数。包含了修改和查询操作。
下面m行就是具体的操作了。
C i x 表示为第i个元素加上x，x范围在1到10000.
Q i j 表示查询区段i到j的和。保证输入的i<=j.
以EOF结束。

输出

输出查询后的区段和。

样例输入

8
1 5 9 11 2 8 15 6
4
Q 1 3
C 2 10
Q 1 4
Q 2 5

样例输出

15
36
37

提示

提示：类型最好定义为__int64

树状数组or线段树裸题，没接触过这种数据结构的可以看一下

涉及到区间修改区间查询，往往使用数据结构去维护

#include <stdio.h>

typedef __int64 ll;

const int N =;

ll c[N];

int n;

void read(int &x)

{

    char c;

    int ans=;

    for(c=getchar(); c<''||c>''; c=getchar());

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

        ans=(ans<<)+(ans<<)+(c-''),c=getchar();

    x=ans;

}

int lowbit(int x)

{

    return x&-x;

}

void add(int x,int d)

{

    while(x<=n)

    {

        c[x]+=d;

        x+=lowbit(x);

    }

}

ll sum(int x)

{

    ll ans=;

    while(x>)

    {

        ans+=c[x];

        x-=lowbit(x);

    }

    return ans;

}

int main()

{

    while(~scanf("%d",&n))

    {

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

            c[i]=;

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

        {

            int x;

            read(x);

            add(i,x);

        }

        int m;

        read(m);

        while(m--)

        {

            char c=getchar();

            int a,b;

            read(a),read(b);

            if(c=='Q')printf("%I64d\n",sum(b)-sum(a-));

            else add(a,b);

        }

    }

    return ;

}

2686: 滑雪

Time Limit(Common/Java):1000MS/10000MS Memory Limit:65536KByte
Total Submit: 766 Accepted:218

Description

Michael喜欢滑雪百这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子

 1  2  3  4 5


16 17 18 19 6


15 24 25 20 7


14 23 22 21 8


13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

Input

每组数据的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。输入以EOF结束

Output

输出最长区域的长度。

Sample Input

5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

Sample Output

要找一条最长的递减序列，但是从一点开始的递减序列的长度我是可以记录的，比他大再到这个点也会有最长路径，所以就是一个记忆化搜索的问题

#include<stdio.h>

const int N=;

int a[N][N],dp[N][N],r,c,t;

int dfs(int x,int y)

{

    int m=;

    if(dp[x][y])return dp[x][y];

    if(x>&&a[x-][y]<a[x][y])t=dfs(x-,y)+,m=t<m?m:t;

    if(x<r-&&a[x+][y]<a[x][y])t=dfs(x+,y)+,m=t<m?m:t;

    if(y<c-&&a[x][y+]<a[x][y])t=dfs(x,y+)+,m=t<m?m:t;

    if(y>&&a[x][y-]<a[x][y])t=dfs(x,y-)+,m=t<m?m:t;

    return dp[x][y]=m;

}

int main()

{

    while(~scanf("%d%d",&r,&c))

    {

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

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

                scanf("%d",&a[i][j]),dp[i][j]=;

        int m=;

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

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

                if(dfs(i,j)>m)m=dp[i][j];

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

    }

    return ;

}

3097: 单词后缀

Time Limit(Common/Java):1000MS/3000MS Memory Limit:65536KByte
Total Submit: 670 Accepted:210

Description

有些英语单词后缀都是一样的，现在我们需要从给定的一堆单词里面找出某个后缀的单词个数。

Input

输入有多组数据。
每组第一行输入n，m，0<=n，m<=100000，
第二行到n+1行：输入单词，每个单词仅有小写英文字母组成，长度不超过10。
第n+2行到n+m+1行，输入要找的单词后缀。

Output

在n个单词里面找出输入单词后缀的单词个数，然后输出。每个数据与数据之间换行。

Sample Input

6 3
someone
everyone
outside
inside
somebody
nobody
one
side
body

Sample Output

2
2
2

字典树裸题

你用map的话带来了一个log的复杂度，但是你只是统计，使用C++的unordered_map也是可以过的

#include<bits/stdc++.h>

using namespace std;

unordered_map<string,int>ma;

int main()

{

    ios::sync_with_stdio(false);

    cin.tie();

    cout.tie();

    string s;

    int n,m;

    while(cin>>n>>m)

    {

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

        {

            cin>>s;

            for(int j=; s[j]; j++)ma[s.substr(j)]++;

        }

        while(m--)

        {

            string c;

            cin>>c;

            cout<<ma[c]<<endl;

        }

        ma.clear();

    }

    return ;

}

1060: 鹊桥相会

Time Limit(Common/Java):1000MS/10000MS Memory Limit:65536KByte
Total Submit: 1471 Accepted:384

Description

一年一度的七夕又要到了，可歌可泣的牛郎织女又可以在鹊桥相会了。不知道大家有没有雅兴陪redraiment坐在葡萄藤下倾听他们的对话。
我们知道，牛郎要与织女相见，必须要有喜鹊搭桥。所以，牛郎必须在天河岸上等待，直到有喜鹊经过，于是牛郎可以搭乘这只喜鹊往河对岸走。当然，牛郎急着去见织女，所以在途中，如果有速度更快的喜鹊赶上了他，他就会换乘那只速度更快的喜鹊。
我们可以假定喜鹊的速度是恒定不变的，并且喜鹊一直是沿直线飞行的(不转弯，更不回头)，牛郎坐上喜鹊所花的时间忽略不计。
现给出天河的宽度、每只喜鹊的初始位置(我们设牛郎所在位置为0，天河方向为正方向)以及它们的速度(有可能是负数，代表喜鹊往反方向飞行)，这些数据都是整数。请你来帮忙计算一下牛郎到达对岸与织女相会最少需要多少时间，让他们早些有情人终成眷属。^_^
当然，如果没有喜鹊来搭载牛郎，我们可怜的牛郎就到不了对岸与织女相会了，那我们只好很遗憾的跟牛郎说：“Can't Solve”，我们祈祷不要发生这样的事情。

Input

第一行有两个数据w、n，分别代表天河的宽度(单位:km)和喜鹊的只数(1≤w≤1000, 1≤n≤10000)。
接下来从第二行到第n+1行每行都有两个数据t、v，分别代表1只喜鹊的初始位置(单位:m)和它的飞行速度(单位:m/s)(-1000≤t≤1000, -100≤v≤100)。
所有的数据范围都不会超过32位整数的表示范围(用int型数据不会溢出)。
输入以0 0结束。

Output

如果牛郎能到达对岸输出他到达对岸所花的总时间(结果精确到秒即可，小数部分舍去)；否则输出“Can't Solve”。

Sample Input

1 1
0 1
0 0

Sample Output

1000

这就是简单的小模拟，需要单位转换，注意细节就行了

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

int main()

{

    int w,n;

    while(scanf("%d%d",&w,&n),w||n)

    {

        int ma=INT_MAX;

        for(int i=,t,v; i<n; i++)

        {

            cin>>t>>v;

            if(t>||v<=)continue;

            int time=(*w-t)/v;

            if(time<ma)ma=time;

        }

        if(ma==INT_MAX)cout<<"Can't Solve\n";

        else cout<<ma<<endl;

    }

    return ;

}

1205: 斐波那契数列

Time Limit(Common/Java):1000MS/10000MS Memory Limit:65536KByte
Total Submit: 2476 Accepted:365

Description

一个斐波那契序列，F(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2) (n>=2)，根据n的值，计算斐波那契数F(n)，其中0≤n≤1000。

Input

输入数据的第一行为测试用例的个数t，接下来为t行，每行为一个整数n（0≤n≤1000）。

Output

输出每个测试用例的斐波那契数F(n)。

Sample Input

2
1
2

Sample Output

1
1

大数模拟，不过这种题目还是直接上Java比较舒服，不会Java这个可以学习一下，算是比较常用的技巧了

solution from htmrc1

import java.math.BigInteger;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner cin=new Scanner(System.in);

        BigInteger []fib=new BigInteger[1010];

        fib[0]=BigInteger.valueOf(0);

        fib[1]=BigInteger.valueOf(1);

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

        {

            fib[i]=fib[i-1].add(fib[i-2]);

        }

        int t=cin.nextInt();

        while(t-->0)

        {

            int n=cin.nextInt();

            System.out.println(fib[n]);

        }

    }

}

1237: 排名

Time Limit(Common/Java):1000MS/10000MS Memory Limit:65536KByte
Total Submit: 464 Accepted:214

Description

今天的上机考试虽然有实时的Ranklist，但上面的排名只是根据完成的题数排序，没有考虑
每题的分值，所以并不是最后的排名。给定录取分数线，请你写程序找出最后通过分数线的
考生，并将他们的成绩按降序打印。

Input

测试输入包含若干场考试的信息。每场考试信息的第1行给出考生人数N ( 0 < N
< 1000 )、考题数M ( 0 < M < = 10 )、分数线（正整数）G；第2行排序给出第1题至第M题的正整数分值；以下N行，每行给出一
名考生的准考证号（长度不超过20的字符串）、该生解决的题目总数m、以及这m道题的题号
（题目号由1到M）。
当读入的考生人数为0时，输入结束，该场考试不予处理。

Output

对每场考试，首先在第1行输出不低于分数线的考生人数n，随后n行按分数从高
到低输出上线考生的考号与分数，其间用1空格分隔。若有多名考生分数相同，则按他们考
号的升序输出。

Sample Input

4 5 25
10 10 12 13 15
CS004 3 5 1 3
CS003 5 2 4 1 3 5
CS002 2 1 2
CS001 3 2 3 5
1 2 40
10 30
CS001 1 2
2 3 20
10 10 10
CS000000000000000001 0
CS000000000000000002 2 1 2
0

Sample Output

3
CS003 60
CS001 37
CS004 37
0
1
CS000000000000000002 20

Source

G是真的模拟题，模拟就完事，所以我没懂为啥有人这个题目都没做

#include<stdio.h>

#include<string.h>

#include <algorithm>

using namespace std;

struct st

{

    char name[];

    int score;

} data[];

int cmp(st a,st b)

{

    if(a.score!=b.score)

        return a.score>b.score;

    else if (strcmp(a.name,b.name)<)

        return ;

    else

        return ;

}

int main()

{

    int i,n,m,l,x,k,sum,ans;

    while(scanf("%d",&n)&&n)

    {

        scanf("%d%d",&m,&l);

        int c[]= {};

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

        {

            scanf("%d",&c[i]);

        }

        for(i=,ans=; i<=n; i++)

        {

            sum=;

            scanf("%s%d",data[i].name,&k);

            while(k--)

            {

                scanf("%d",&x);

                sum+=c[x];

            }

            data[i].score=sum;

            if(data[i].score>=l)

                ans++;

        }

        sort(data+,data+n+,cmp);

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

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

            printf("%s %d\n",data[i].name,data[i].score);

    }

    return ;

}

1336: 小数化分数

Time Limit(Common/Java):1000MS/10000MS Memory Limit:65536KByte
Total Submit: 388 Accepted:220

Description

Ray 在数学课上听老师说，任何小数都能表示成分数的形式，他开始了化了起来，很快他就完成了，但他又想到一个问题，如何把一个循环小数化成分数呢?
请你写一个程序不但可以将普通小数化成最简分数，也可以把循环小数化成最简分数。

Input

第一行是一个整数N，表示有多少组数据。
每组数据只有一个纯小数，也就是整数部分为0。小数的位数不超过9位，循环部分用()括起来。

Output

对每一个对应的小数化成最简分数后输出，占一行。

Sample Input

3
0.(4)
0.5
0.32(692307)

Sample Output

4/9
1/2
17/52

循环小数的话其实都是与9有关，我的代码太丑了，就不放出来了，是一个挺有意思的题目

4261: 判断日期

Time Limit(Common/Java):1000MS/3000MS Memory Limit:65536KByte
Total Submit: 547 Accepted:111

Description

输入两个日期，输出较早的日期。如果输入的日期不合法则输入error！。

Input

测试数据有多组。输入格式为:年\月\日，年，月，日非负。

Output

输出：年-月-日，没有前导零

Sample Input

2012\12\21
2012\11\21
2012\12\21
2012\13\12

Sample Output

2012-11-21
error!

这种水题比较适合新生赛，练练手就好，其实没啥意义

#include <stdio.h>

static int valid_date(int y, int m, int d)

{

    int month[]= {,,,,,,,,,,,};

    if((y%==&&y%!=)||y%==)

        month[]=;

    return m>&&m<=&&d>&&d<=month[m-];

}

int main()

{

    int y1,m1,d1,y2,m2,d2;

    while(scanf("%4d\\%2d\\%2d%4d\\%2d\\%2d",&y1,&m1,&d1,&y2,&m2,&d2)!=EOF)

    {

        if (valid_date(y1,m1,d1)&&valid_date(y2,m2,d2))

        {

            if(y1*+m1*+d1>=y2*+m2*+d2)

                printf("%d-%d-%d\n",y2,m2,d2);

            else

                printf("%d-%d-%d\n",y1,m1,d1);

        }

        else

            printf("error!\n");

    }

    return ;

}

4773: 回文数

Time Limit(Common/Java):1000MS/3000MS Memory Limit:65536KByte
Total Submit: 48 Accepted:13

Description

若一个数（首位不为0）从左到右读与从右到左读都是一样，这个数就叫做回文数，例如12521就是一个回文数。

给定一个N进制正整数，把它的各位数字上数字倒过来排列组成一个新数，然后与原数相加，如果是回文数则停止，如果不是，则重复这个操作，直到和为回文数为止。例如：10进制87则有：

STEP1: 87+78=165
STEP2: 165+561=726
STEP3: 726+627=1353
STEP4: 1353+3531=4884

任务：写一个程序，给定一个N（2≤N≤16）进制数m（10~15用大写字母A~F表示），m的位数上限为20。求最少经过几步可以得到回文数。如果在30步以内（包括30步）不可能得到回文数，则输出“Impossible”，否则输出生成该回文数的最少步数。

Input

输入有两行，每行一个数，即N和N进制整数m。

Output

若最少在30步以内得到回文数,则输出步数；

如果在30步以内（包含30步）不可能得到回文数，则输出“Impossible”(无引号)

Sample Input

9
87

Sample Output

这个同样去模拟就好了

最后一题更是个大模拟，学操作系统的你可以尝试一下