【题解】新学期第一课！题目！

来源：互联网发布：淘宝怎么直播呀编辑：程序博客网时间：2024/06/05 00:12

USACO2015 US OPEN BRONZE

PROBLEM1 MOOCRYPTION

众所不知的，奶牛们很喜欢玩智力游戏。John农夫最近发明了一个有趣的“找单词”游戏。这个游戏的例子如下：

USOPEN

OOMABO

MOOMXO

PQMROM

作为奶牛，他们只对单词“MOO”有兴趣，这个可能会出现在找单词游戏中的任何地方，可能是水平的，可能是垂直的，也有可能是对角线的出现。上面的例子出现了6个MOO。

John农夫也是单词游戏的粉丝。由于奶牛们不想在他们有机会试一下之前，John就把解开了，他们把游戏的内容用一个代替密码给加密了。这个代替密码将字母表里的每个字母用另外一个字母代替了。比如说，A可能对应着X， B可能对应着A等等。没有哪个字母和自己对应，没有两个字母对应到同样一个字母上（否则解码时会引起歧义）。

不幸的是，这群傻奶牛不记得用来解码的代替密码了。所以求求你帮他们找到一个合适的代替密码，使这个游戏中出现MOO的次数最多。

输入格式（moocrypt.in）：

第一行包括N和M，分别表示这个游戏的行与列（每个最多50）。接下来的N行，每行包括M个字符，来表示这个游戏的一行。每个字符都是从A-Z之间的一个大写字母。

输出格式（moocrypt.out）：

输出当游戏用合适的代替密码解码后可以出现的最多MOO的次数

输入样例：

4 6

TAMHGI

MMQVWM

QMMQSM

HBQUMQ

输出样例：

这个就是题目描述中的加密后的游戏。这里M和O分别用Q和M代替了。

PROBLEM2 BESSIE GETS EVEN

FJ 和奶牛Bessie最爱闲时交换数学智力游戏。最近一次FJ给Bessie 的数学难倒了可怜的Bessie。现在她想为FJ给他那么难的题目而复仇。

Bessie 给了FJ 一个表达式，(B+E+S+S+I+E)(G+O+E+S)(M+O+O)，包括七个变量，B,E,S,I,G,O,M （其中O 是变量不时数字0）。对每个变量，她给了FJ一个那个变量可能被赋有最多有20个整数值的清单。她问FJ总共有多少种不同的方式来给每个变量赋值使得表达式的最终结果为偶数。

输入格式：（geteven.in）

第一行包括一个整数Ｎ，接下来的Ｎ行，每行包括一个变量以及这个变量可能的值。　每个变量会至少出现一次，最多出现20次。同一个的变量不会被列两次相同的值。每个值都会在-300到300之间。

输出格式：（geteven.out）

输出一个整数，表示所有FJ可以给这些变量赋值使得表达式最终的结果是偶数的可能数。

输入样例：

B 2

E 5

S 7

I 10

O 16

M 19

B 3

G 1

I 9

M 2

输出样例：

共有6种变脸赋值的方法：

(B,E,S,I,G,O,M) = (2, 5, 7, 10, 1, 16, 19) -> 53,244

                = (2, 5, 7, 10, 1, 16, 2 ) -> 35,496

                = (2, 5, 7, 9,  1, 16, 2 ) -> 34,510

                = (3, 5, 7, 10, 1, 16, 2 ) -> 36,482

                = (3, 5, 7, 9,  1, 16, 19) -> 53,244

                = (3, 5, 7, 9,  1, 16, 2 ) -> 35,496

注意(2,5,7,10,1,16,19)和(3,5,7,9,1,16,19) 算两种不同的赋值方法，尽管他们得出的结果是相同的。

PROBLEM3 TRAPPED IN THE HAYBALES

FJ 收到了N个大干草捆（1 < N < 4000）然后将这些干草随意的放在放到通往养牛场的路的任意位置上。不幸的是，他忘了奶牛Bessie正在路上散步，她有可能被这些捆困住。

每个捆j的大小为S_j, 在某个独特的位置P_j处，这个位置是一维马路上的一点。奶牛Bessie从一个没有草堆的地方出发，　他可以自由的在这条马路上走来走去，甚至走到某一捆干草所在的位置，但她不能穿过那个点。但有个例外，如果她朝着一个方向跑D各单位的距离，她可以积攒到足够的速度冲破一个大小小于D的干草捆，　这之后，那个干草捆就永远的被消灭了。当然，这之后，她可能开拓了更多的空间，使她可以跑向其他的干草捆，　并消灭这些捆。

Bessie如果她最终突围了最左边或最右边的任意一个甘草捆，她就逃脱了。请计算出路上Bessie无法逃脱的起始位置的总面积。比如说，如果Bessie的起始位置是在两捆之间从１到５的位置上，而且在这中间Bessie 无法逃脱，那么她无法逃脱的面积就为４。

输入格式：（trapped.in）

第一行包括数字Ｎ，接下来的Ｎ行每行表示一个干草捆，包括两个整数，分别表示这个捆的大小和位置。每个值在1 ~ 10^9 之间。

输出格式：（trapped.out）

输出一个整数，表示Bessie 在这条路上无法逃脱的起始位置的面积。

输入样例：

8 1

1 4

8 8

7 15

4 20

输出样例：

PROBLEM 4 PALINDROMICPATHS

FJ的农场是一个N*N格子形状的一块地（2<N<18），每个格子用一个字母表示，比如：

ABCD

BXZX

CDXB

WCBA

每天，Bessie奶牛从左上角走向右下角，她每一步可以向右或向下走。 Bessie记录着她走的过程中所产生的字符串。她的方向感很差，所以生成出来的字符串要是回文串（从前和从后读是一样的），因为她不记得她曾经走过的方向。

帮Bessie她可以走出的不同的回文串的个数。沿不同路径走出的相同的回文串只算一次。比如说，上面的例子中有多种不同的路径可以产生出回文串ABXZXBA，但Bessie只能走出四种不同的回文串：ABCDCBA, ABCWCBA,ABXZXBA, ABXDXBA 。

输入格式：（palpath.in）

第一行包括一个整数N，剩下的N行每行包括N个在A-Z之间的字符，表示这块农场。

输出格式：（palpath.out）

输出Bessie可能走出的不同的回文串的个数。

输入样例：

ABCD

BXZX

CDXB

WCBA

输出样例：

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

char ch[55][55];
char w1,w2;
int ans;
int tmp;
int a[]={-1,-1,0,1,1,1,0,-1},b[]={0,1,1,1,0,-1,-1,-1};
int c[]={-2,-2,0,2,2,2,0,-2},d[]={0,2,2,2,0,-2,-2,-2};
int n,m; 

void check(int x,int y)
{
for(int i=0;i<8;++i)
{
if( ch[x+a[i]][y+b[i]]==w2 && ch[x+c[i]][y+d[i]]==w2 )
++tmp;
}
} 

int main()
{
freopen("moocrypt.in","r",stdin);
freopen("moocrypt.out","w",stdout);

memset(ch,'0',sizeof(ch));
cin>>n>>m;
for(int i=2;i<n+2;++i)
for(int j=2;j<m+2;++j)
cin>>ch[i][j];

for(int i=0;i<26;++i)
for(int j=0;j<26;++j)
if(i!=j)
{
tmp=0;
w1=i+'A';
w2=j+'A';
for(int k=2;k<n+2;++k)
for(int kk=2;kk<m+2;++kk)
if(ch[k][kk]==w1)
check(k,kk);
if(tmp>ans)
ans=tmp;
}

cout<<ans<<endl;
}

#include<iostream>
#include<cstdio>
using namespace std;

int n,x;
struct fuck
{
int ge;
int num[21];
};
fuck k[27];

int t1,t2,t3,ans,k1,k2,k3;
char ch;

int main()
{
freopen("geteven.in","r",stdin);
freopen("geteven.out","w",stdout);
cin>>n;

for(int i=0;i<n;++i)
{
cin>>ch>>x;
k[ch-'A'].num[k[ch-'A'].ge]=x;
k[ch-'A'].ge++;
}

for(int i=0;i<k[1].ge;++i)
for(int z=0;z<k[8].ge;++z)
if( ( k[1].num[i] + k[8].num[z] ) %2 ==0)
++t1;
k1=k[1].ge*k[8].ge-t1;

for(int i=0;i<k[6].ge;++i)
for(int j=0;j<k[14].ge;++j)
for(int y=0;y<k[4].ge;++y)
for(int z=0;z<k[18].ge;++z)
if( ( k[6].num[i] + k[14].num[j] + k[4].num[y] +k[18].num[z] ) %2 ==0)
++t2;
k2=k[6].ge*k[14].ge*k[4].ge*k[18].ge-t2;

for(int i=0;i<k[12].ge;++i)
if( ( k[12].num[i] ) %2 ==0)
++t3;
k3=k[12].ge-t3;

ans=t1*k2*k3+t2*k1*k3+t3*k1*k2+t1*t2*k3+t1*t3*k2+t2*t3*k1+t1*t2*t3;
cout<<ans<<endl;
}

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;

int n;
struct fuck
{
int s,p,next;
};
fuck c[4001];

int cmp(fuck a,fuck b)
{
return a.p<b.p;
}
int beg,ans;

int main()
{
freopen("trapped.in","r",stdin);
freopen("trapped.out","w",stdout);

cin>>n;
for(int i=0;i<n;++i)
{
cin>>c[i].s>>c[i].p;
c[i].next=i+1;
}
sort(c+0,c+n,cmp);

beg=0;
for(int i=1;i<n;++i)
{
if(c[i].p-c[beg].p>c[i].s)
c[beg].next=i+1;
else
beg=i;
}
//for(int i=0;i<n;++i)
//cout<<c[i].next<<" ";

beg=0;

while(true)
{
if(c[c[beg].next].p-c[beg].p>c[beg].s)
beg=c[beg].next;
else
break;
}

//cout<<beg<<endl;

while(beg<n&&c[beg].next<n)
{
ans+=c[c[beg].next].p-c[beg].p;
beg=c[beg].next;
}
cout<<ans<<endl;
return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

int n;
char ch[20][20];
int head,tail;
string s[10000],tot[10000];
int ge;

bool check(string q)
{
for(int i=0;i<ge;++i)
if(tot[i]==q)
return false;
return true;
}

struct fuck
{
string st;
int l,x,y,x2,y2;
};
fuck k[100000];

int a[]={0,1},b[]={1,0};
int c[]={0,-1},d[]={-1,0};

int main()
{
freopen("palpath.in","r",stdin);
freopen("palpath.out","w",stdout);

cin>>n;
for(int i=0;i<n;++i)
for(int j=0;j<n;++j)
cin>>ch[i][j];

if(ch[0][0]!=ch[n-1][n-1])
{
cout<<0<<endl;
return 0;
}
//cout<<endl;

head=tail=0;
k[0].l=k[0].x=k[0].y=0;
k[0].x2=k[0].y2=n-1;
k[0].st+=ch[0][0];
while(head<=tail)
{
int xx=k[head].x,yy=k[head].y;
int xxx=k[head].x2,yyy=k[head].y2;
int ll=k[head].l;
string ss=k[head].st;

if(ll==n/2+1)
{
if(xx==xxx&&yy==yyy)
{
if(check(ss))
{
tot[ge]=ss;
++ge;
}
}
++head;
continue;
}

for(int i=0;i<2;++i)
for(int j=0;j<2;++j)
{
int nx=xx+a[i],ny=yy+b[i];
int nnx=xxx+c[j],nny=yyy+d[j];
if(ch[nx][ny]==ch[nnx][nny])
{
++tail;
k[tail].x=nx;k[tail].y=ny;
k[tail].x2=nnx;k[tail].y2=nny;
k[tail].l=ll+1;
k[tail].st=ss+ch[nx][ny];
}
}
++head;
}
/*for(int i=0;i<ge;++i)
cout<<tot[i]<<endl;*/
cout<<ge<<endl;
}

0 0