A. Dreamoon and Stairs
time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Dreamoon wants to climb up a stair of n steps. He can climb
1 or 2 steps at each move. Dreamoon wants the number of moves to be a multiple of an integer
m.

What is the minimal number of steps making him climb to the top of the stairs that satisfies his condition?

Input

The single line contains two space separated integers n,
m (0 < n ≤ 10000, 1 < m ≤ 10).

Output

Print a single integer — the minimal number of moves being a multiple of
m. If there is no way he can climb satisfying condition print
 - 1 instead.

Sample test(s)
Input
10 2
Output
6
Input
3 5
Output
-1
Note

For the first sample, Dreamoon could climb in 6 moves with following sequence of steps: {2, 2, 2, 2, 1, 1}.

For the second sample, there are only three valid sequence of steps {2, 1}, {1, 2}, {1, 1, 1} with 2, 2, and 3 steps respectively. All these numbers are not multiples of 5.

题意:给两个数n,m。



如今要求爬楼梯。一次能够爬



一个或两个阶梯,要求爬完n个阶梯,



求爬的次数为m的倍数时,最少次数是多少,



若不存在答案输出-1。

做法:非常明显尽量爬两步。

代码:

#include<iostream>
#include<map>
#include<string>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
int n,m,x,y;
cin>>n>>m;
x=n/2+n%2;
y=n/2;
while(y>-1)
{
if(x%m==0)
{
cout<<x<<endl;
return 0;
}
x++;
y--;
}
cout<<-1<<endl;
}

B. Dreamoon and WiFi
time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Dreamoon is standing at the position 0 on a number line. Drazil is sending a list of commands through Wi-Fi to Dreamoon's smartphone and Dreamoon follows them.

Each command is one of the following two types:

  1. Go 1 unit towards the positive direction, denoted as
    '+'
  2. Go 1 unit towards the negative direction, denoted as
    '-'

But the Wi-Fi condition is so poor that Dreamoon's smartphone reports some of the commands can't be recognized and Dreamoon knows that some of them might even be wrong though successfully recognized. Dreamoon decides to follow every recognized command and
toss a fair coin to decide those unrecognized ones (that means, he moves to the
1 unit to the negative or positive direction with the same probability
0.5).

You are given an original list of commands sent by Drazil and list received by Dreamoon. What is the probability that Dreamoon ends in the position originally supposed to be final by Drazil's commands?

Input

The first line contains a string s1 — the commands Drazil sends to Dreamoon, this string consists of only the characters in the set {'+',
'-'}.

The second line contains a string s2 — the commands Dreamoon's smartphone recognizes, this string consists of only the characters in the set {'+',
'-', '?'}.
'?' denotes an unrecognized command.

Lengths of two strings are equal and do not exceed 10.

Output

Output a single real number corresponding to the probability. The answer will be considered correct if its relative or absolute error doesn't exceed
10 - 9.

Sample test(s)
Input
++-+-
+-+-+
Output
1.000000000000
Input
+-+-
+-? ?
Output
0.500000000000
Input
+++
??-
Output
0.000000000000
Note

For the first sample, both s1 and
s2 will lead Dreamoon to finish at the same position
 + 1.

For the second sample, s1 will lead Dreamoon to finish at position 0, while there are four possibilites for
s2: {"+-++",
"+-+-", "+--+",
"+---"} with ending position {+2, 0, 0, -2} respectively. So there are
2 correct cases out of 4, so the probability of finishing at the correct position is
0.5.

For the third sample, s2 could only lead us to finish at positions {+1, -1, -3}, so the probability to finish at the correct position
 + 3 is 0.

题意:给两个长度不超过10的同样长度的串。



第一个串由+和-组成,



第二个串由+和-和?组成。



初始状态为0。+代表+1,-代表-1,



如今要求上下结果状态同样时,概率是多少。

做法:先推断是否有解,若无解输出0,



若有解,求出第二个串还须要多少个+,



统计?的数量,求出组合数除以全部的可能数量。



或者。直接爆搜,由于最多仅仅有10个字符。



所以,不会超时。

代码:

#include<iostream>
#include<map>
#include<string>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
int s1,s2,s3;
void dfs(int step,int val)
{
if(step==s2)
{
if(val==s1)
s3++;
return;
}
dfs(step+1,val+1);
dfs(step+1,val-1);
}
int main()
{
string a,b;
int n,i;
cin>>a>>b;
n=a.length();
s1=0;
for(i=0;i<n;i++)
if(a[i]=='+')
s1++;
else
s1--;
s2=0;
for(i=0;i<n;i++)
if(b[i]=='+')
s1--;
else if(b[i]=='-')
s1++;
else
s2++;
s3=0;
dfs(0,0);
printf("%.10f",(double)s3/(1<<s2));
}

C. Dreamoon and Sums
time limit per test

1.5 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Dreamoon loves summing up something for no reason. One day he obtains two integers
a and b occasionally. He wants to calculate the sum of all
nice integers. Positive integer
x is called nice if and
, where
k is some
integer number in range [1, a].

By we denote the
quotient of integer division of
x and y. By we denote the
remainder of integer division of
x and y. You can read more about these operations here:
http://goo.gl/AcsXhT.

The answer may be large, so please print its remainder modulo
1 000 000 007 (109 + 7). Can you compute it faster than Dreamoon?

Input

The single line of the input contains two integers a,
b (1 ≤ a, b ≤ 107).

Output

Print a single integer representing the answer modulo 1 000 000 007 (109 + 7).

Sample test(s)
Input
1 1
Output
0
Input
2 2
Output
8
Note

For the first sample, there are no nice integers because is always zero.

For the second sample, the set of nice integers is {3, 5}.

题意:给出两个数a,b,当



div(x,b)/mod(x,b)=k,1<=k<=a时。求出



全部可能的x的和对1 000 000 007取余的结果。



做法:



设y=div(x,b),z=mod(x,b),



能够得到



y=z*k,y*b+z=x,联立得



(kb+1)z=x,



以下用到求和公式,



然后如果k为常量,得到x=b(b-1)*(kb+1)/2。



最后k还原为变量,得到x=b(b-1)/2*[(1+a)a*b/2+a]

代码:

#include<iostream>
#include<map>
#include<string>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
const long long mod=1000000007;
int main()
{
long long a,b,t1,t2,t3;
cin>>a>>b;
t1=(1+a)*a/2%mod;
t1=(t1*b)%mod;
t1=(t1+a)%mod;
t2=b*(b-1)/2%mod;
t3=(t1*t2)%mod;
cout<<t3;
}

D. Dreamoon and Sets
time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Dreamoon likes to play with sets, integers and .
is defined as the largest positive integer that divides both
a and b.

Let S be a set of exactly four distinct integers greater than
0. Define S to be of rank
k if and only if for all pairs of distinct elements
si,
sj from
S, .

Given k and n, Dreamoon wants to make up
n sets of rank k using integers from
1 to m such that no integer is used in two different sets (of course you can leave some integers without use). Calculate the minimum
m that makes it possible and print one possible solution.

Input

The single line of the input contains two space separated integers
n, k (1 ≤ n ≤ 10 000, 1 ≤ k ≤ 100).

Output

On the first line print a single integer — the minimal possible
m.

On each of the next n lines print four space separated integers representing the
i-th set.

Neither the order of the sets nor the order of integers within a set is important. If there are multiple possible solutions with minimal
m, print any one of them.

Sample test(s)
Input
1 1
Output
5
1 2 3 5
Input
2 2
Output
22
2 4 6 22
14 18 10 16
Note

For the first example it's easy to see that set {1, 2, 3, 4} isn't a valid set of rank 1 since
.

题意:



求出n个集合均为4个元素,且每一个集合内随意两两



元素的最大公约数为k。集合不同意有交集,



当n*4个元素最大值最小时。输出全部n个集合。



假设有多组结果输出随意一组。

做法:



非常明显。当随意集合内的全部元素除以k后,



两两元素之间是互质的,然后为了满足元素最大值最小,



在除掉k后,随意集合内肯定是由3个奇数。1个偶数组成。



由于若少一个奇数,就会有至少一对数不互质,



若多一个奇数,元素最大值就会变大。



所以,从1開始构建全部元素集合就可以。

代码:

#include<iostream>
#include<map>
#include<string>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
int n,k;
cin>>n>>k;
cout<<(6*n-1)*k<<endl;
while(n--)
{
cout<<(6*n+1)*k<<" "<<(6*n+2)*k<<" "<<(6*n+3)*k<<" "<<(6*n+5)*k<<endl;
}
}

E. Dreamoon and Strings
time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Dreamoon has a string s and a pattern string
p. He first removes exactly
x characters from s obtaining string
s' as a result. Then he calculates that is defined as the maximal number of non-overlapping
substrings equal to p that can be found in
s'. He wants to make this number as big as possible.

More formally, let's define as maximum value of
over all
s' that can be obtained by removing exactly
x characters from s. Dreamoon wants to know
for all
x from 0 to
|s| where |s| denotes the length of string
s.

Input

The first line of the input contains the string s (1 ≤ |s| ≤ 2 000).

The second line of the input contains the string p (1 ≤ |p| ≤ 500).

Both strings will only consist of lower case English letters.

Output

Print |s| + 1 space-separated integers in a single line representing the
for all
x from 0 to
|s|.

Sample test(s)
Input
aaaaa
aa
Output
2 2 1 1 0 0
Input
axbaxxb
ab
Output
0 1 1 2 1 1 0 0
Note

For the first sample, the corresponding optimal values of
s' after removal 0 through
|s| = 5 characters from s are {"aaaaa",
"aaaa",
"aaa",
"aa",
"a", ""}.

For the second sample, possible corresponding optimal values of
s' are {"axbaxxb",
"abaxxb",
"axbab",
"abab",
"aba",
"ab",
"a", ""}.

题意:



给出两个串,当对第一个串长度为n时,



分别除去1到n个字符能够获得n个新串,



要求每一个新串的子串为第二个串的数量最大,



输出n个新串的所谓最大数量。

做法:



dp[i][j]:第一个串0到i的位置除去j个字符能够得到的最大数量

(j<=i,且除去的位置不包含i)

a[i]:从i開始。包括第二个串的近期位置,若没有赋值为-1。

ns:第一个串的长度

np:第二个串的长度



dp[i+1][j]=max(dp[i][j],dp[i+1][j]);

//若不删除第i个字符dp[i+1][j]=dp[i][j]

dp[i+1][j+1]=max(dp[i][j],dp[i+1][j+1]);

//若删除第i个字符dp[i+1][j+1]=dp[i][j]

if(a[i]>0)

dp[i+a[i]][j+a[i]-np]=max(dp[i][j]+1,dp[i+a[i]][j+a[i]-np]);

//若删除从i開始后到i+a[i]不包括与第二个串同样的字符。

dp[i+a[i]][j+a[i]-np]=dp[i][j]+1



由于dp[ns-1][j]木有考虑ns-1个字符是否删除的情况。



所以终于答案存在dp[ns][j]中。

代码:

#include<iostream>
#include<map>
#include<string>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
int a[2010],dp[2010][2010];
int main()
{
string s,p;
int i,j,k,ns,np;
cin>>s>>p;
ns=s.length();
np=p.length();
for(i=0;i<ns;i++)
{
j=0;k=i;
while(j<np&&k<ns)
{
if(p[j]==s[k])
j++;
k++;
}
a[i]= j==np? k-i:-1;
}
for(i=0;i<ns;i++)
for(j=0;j<=i;j++)
{
dp[i+1][j]=max(dp[i][j],dp[i+1][j]);
dp[i+1][j+1]=max(dp[i][j],dp[i+1][j+1]);
if(a[i]>0)
dp[i+a[i]][j+a[i]-np]=max(dp[i][j]+1,dp[i+a[i]][j+a[i]-np]);
}
i=ns;
cout<<dp[i][0];
for(j=1;j<=ns;j++)
cout<<" "<<dp[i][j];
}

Codeforces Round #272 (Div. 2)AK报告的更多相关文章

  1. Codeforces Round #272 (Div. 2) 题解

    Codeforces Round #272 (Div. 2) A. Dreamoon and Stairs time limit per test 1 second memory limit per ...

  2. Codeforces Round #324 (Div. 2)解题报告

    ---恢复内容开始--- Codeforces Round #324 (Div. 2) Problem A 题目大意:给二个数n.t,求一个n位数能够被t整除,存在多组解时输出任意一组,不存在时输出“ ...

  3. Codeforces Round #384 (Div. 2) 解题报告

    这场CF水题都非常的水,D题如果对树.DFS相关比较熟练的话也不难.比赛时前三题很快就过了,可是因为毕竟经验还是太少,D题就卡住了.比赛之后A题还因为没理解对题意fst了--(为什么这次就没人来hac ...

  4. Codeforces Round #382 (Div. 2) 解题报告

    CF一如既往在深夜举行,我也一如既往在周三上午的C++课上进行了virtual participation.这次div2的题目除了E题都水的一塌糊涂,参赛时的E题最后也没有几个参赛者AC,排名又成为了 ...

  5. Codeforces Round #380 (Div. 2) 解题报告

    第一次全程参加的CF比赛(虽然过了D题之后就开始干别的去了),人生第一次codeforces上分--(或许之前的比赛如果都参加全程也不会那么惨吧),终于回到了specialist的行列,感动~.虽然最 ...

  6. Codeforces Round #216 (Div. 2)解题报告

    又范低级错误! 只做了两题!一道还被HACK了,囧! A:看了很久!应该是到语文题: 代码:#include<iostream> #include<];    ,m2=;    ;i ...

  7. Codeforces Round #272 (Div. 2) C. Dreamoon and Sums (数学 思维)

    题目链接 这个题取模的时候挺坑的!!! 题意:div(x , b) / mod(x , b) = k( 1 <= k <= a).求x的和 分析: 我们知道mod(x % b)的取值范围为 ...

  8. Codeforces Round #272 (Div. 2)

    A. Dreamoon and Stairs 题意:给出n层楼梯,m,一次能够上1层或者2层楼梯,问在所有的上楼需要的步数中是否存在m的倍数 找出范围,即为最大步数为n(一次上一级),最小步数为n/2 ...

  9. Codeforces Round #272 (Div. 1) Problem C. Dreamoon and Strings

    C. Dreamoon and Strings time limit per test 1 second memory limit per test 256 megabytes input stand ...

随机推荐

  1. 「OC」构造方法和分类

    一.构造方法 (一)构造方法的调用 创建一个可用的对象:Person *p=[Person new]; new方法实际上是分为两步来创建一个对象: 1)使用+alloc方法来分配存储空间(返回分配的对 ...

  2. javascript单元测试(转)

    1.      什么是单元测试 在计算机编程中,单元测试(又称为模块测试)是针对程序模块(软件设计的最小单位)来进行正确性检验的测试工作.程序单元是应用的最小可测试部件.在过程化编程中,一个单元就是单 ...

  3. Muduo 网络编程示例之零:前言

    陈硕 (giantchen_AT_gmail)Blog.csdn.net/Solstice Muduo 全系列文章列表: http://blog.csdn.net/Solstice/category/ ...

  4. hdu 4679 (树形DP)

    题意:给一棵树,边的权值都是1,摧毁每条边是有代价的,选择摧毁一条边,把一棵树分成两部分,求出两部分中距离最大的两点的距离,求出距离*代价最小的边,多条的话输出序号最小的. 刚开始理解错题意了,wro ...

  5. CSS实现背景图尺寸不随浏览器大小而变化的两种方法

    一些网站的首页背景图尺寸不随浏览器缩放而变化,本例使用CSS 实现背景图尺寸不随浏览器缩放而变化,方法一. 把图片作为background,方法二使用img标签.喜欢的朋友可以看看   一些网站的首页 ...

  6. DDFT

    得知DIP文章4日 傅立叶变换数学原理将可能完全被引入,下仅仅实现代码.观察下结果,公式在上一篇博客中已经描写叙述 上代码: // // main.c // Fourer2D // // Create ...

  7. 工作需要稍微研究了一下Hyper-V

    Hyper-V是指微软的虚拟化技术,底层用得Hypervisior好像没有特殊的名字 虚拟化市场占有率前三:VMWare,Hyper-V,Citrix Citrix的XenServer今年彻底开源,原 ...

  8. 如何使用notepad++搭配MinGW配置编译C/C++

    最经开始学C++了,平时学习不喜欢用IDE,一直以来都喜欢使用sublimetext写代码.所以在网上找了一下如何配置sublimetext编译C/C++.不过简单配置之后,只有输出,要想进行输出操作 ...

  9. U3D学习笔记

    1.向量的点乘.叉乘以及归一化的意义 1)点乘描述了两个向量的相似程度,结果越大两向量越相似,还可表示投影 2)叉乘得到的向量垂直于原来的两个向量 3)标准化向量:用在只关系方向,不关心大小的时候 用 ...

  10. BZOJ 3040: 最短路(road) ( 最短路 )

    本来想学一下配对堆的...结果学着学着就偏了... 之前 kpm 写过这道题 , 前面的边不理它都能 AC .. 我也懒得去写前面的加边了... 用 C++ pb_ds 库里的 pairing_hea ...