BestCoder 百度之星2016

相应的算法将在这道题的AC代码中写出。

importjava.util.Scanner;

publicclassMain{

staticint[]H=newint[100001];
staticintmods=9973;

publicstaticvoidmain(String[]args){
Scannersc=newScanner(System.in);
while(sc.hasNext()){
intN=sc.nextInt();
Stringstr=sc.next();

getHashFactor(str);
for(inti=0;i<N;i++){
intbegin=sc.nextInt()-1;
intend=sc.nextInt();
System.out.println(getHashCode(begin,end));
}
}
}
//保存从开始到当前位置前面字符串的hash值
privatestaticvoidgetHashFactor(Stringss){
intlen=ss.length();
H[0]=1;
for(inti=1;i<=len;i++){
H[i]=H[i-1]*(ss.charAt(i-1)-28)%mods;
}
}
//利用费马小定理和乘法逆元
privatestaticintgetHashCode(intbegin,intend){
return(int)(H[end]*mod_pow(H[begin],mods-2,mods)%mods);
}
//快速模取幂算法
privatestaticlongmod_pow(longx,longn,longmod){
longres=1;
while(n>0){
if((n&1)!=0)res=res*x%mod;
x=x*x%mod;
n>>=1;
}
returnres;
}
}

ProblemD

5
ACM
MAC
BBA
ACM
BAB

0
1
0
2
1

思路：关键要想到java里面Arrays.sort()函数可以将字符数组按照ascii码排序。排序之后，同一个名字所组成的字符串就相同了，
再利用HashMap，键记录名字，值记录当前已出现的次数，每遇到一次就把值加一，更新map里的值部分。

importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.util.Arrays;
importjava.util.HashMap;
importjava.util.Map;publicclassMain{
publicstaticvoidmain(Stringargs[])throwsIOException{
InputStreamReaderis=newInputStreamReader(System.in);
BufferedReaderbr=newBufferedReader(is);
Stringstr="";
while((str=br.readLine())!=null){
intn=Integer.valueOf(str);
Map<String,Integer>m=newHashMap<String,Integer>();
for(inti=0;i<n;i++){
char[]sa=br.readLine().toCharArray();
Arrays.sort(sa);
Stringsorted=newString(sa);
if(m.containsKey(sorted)){
m.put(sorted,m.get(sorted)+1);
System.out.println(m.get(sorted));
}else{
m.put(sorted,0);
System.out.println(0);
}
}
}
}
}

需要注意的是Map里面存储的是对象，所以在将排序好的字符数组put进map的时候，需要新建String对象，而不能直接put，要不然无法判断是否相等，
在利用equals函数判断时，也是如此。看下面的代码即可。

publicclassMain{
publicstaticvoidmain(Stringargs[])throwsIOException{
Stringa="ss";
Stringb="ss";
char[]arr={'s','s'};
Stringc=arr.toString();
Stringd=newString(arr);
if(a.equals(b))
System.out.println("a==b");
else
System.out.println("a!=b");
if(a.equals(c))
System.out.println("a==c");
else
System.out.println("a!=c");
if(a.equals(d))
System.out.println("a==d");
else
System.out.println("a!=d");
if(c.equals(d))
System.out.println("c==d");
else
System.out.println("c!=d");
if("ss".equals("ss"))
System.out.println("ss==ss");
else
System.out.println("ss!=ss");
}
}

打印结果是：

ProblemB

1
3
5

1
3
8

importjava.math.BigInteger;
importjava.util.Scanner;publicclassMain{
publicstaticvoidmain(String[]args){
Scannersc=newScanner(System.in);
intmax=1;
System.out.println(Long.MAX_VALUE);
BigInteger[]bi=newBigInteger[201];
bi[0]=newBigInteger("1");
bi[1]=newBigInteger("1");
while(sc.hasNext()){
intn=sc.nextInt();
while(n>max){
bi[max+1]=bi[max].add(bi[max-1]);
max++;
}
System.out.println(bi
);
}
}
}

1004放盘子

2
4502.5
45.53

Case#1:
Givemeakiss!
Case#2:
Iwanttokissyou!

importjava.util.Scanner;publicclassMain{
publicstaticvoidmain(String[]args){
Scannersc=newScanner(System.in);
while(sc.hasNext()){
intt=sc.nextInt();
for(inti=1;i<=t;i++){
intn=sc.nextInt();
doublea=sc.nextDouble();
doubler=sc.nextDouble();
doublera=a/2*1/Math.tan(Math.PI/n);
System.out.println("Case#"+i+":");
if(ra>=r)
System.out.println("Givemeakiss!");
else
System.out.println("Iwanttokissyou!");
}
}
}
}

1003IP聚合

2
52
192.168.1.0
192.168.1.101
192.168.2.5
192.168.2.7
202.14.27.235
255.255.255.0
255.255.0.0
42
127.127.0.1
10.134.52.0
127.0.10.1
10.134.0.2
235.235.0.0
1.57.16.0

Case#1:
3
2
Case#2:
3
4其实是一个很简单的题，但是容易掉进思维陷阱（当然可能是我太笨了）。一开始想的是将ip分段与掩码按位与，再分段比较。
　　　　再将前一段相同的ip再去比较下一段，思考了半天，这样太复杂，估计会超时，实现起来也有难度。
正确的思路：将每一个ip和子网掩码组合成int类型，int类型也是32位，ip和子网掩码都是32位，所以通过移位操作刚好能组合成int，
再将组合之后的int类型的ip与子网掩码按位与，结果放入set里面，set的大小即结果了。

importjava.io.IOException;
importjava.util.HashSet;
importjava.util.Scanner;
importjava.util.Set;publicclassMain{
publicstaticvoidmain(String[]args)throwsIOException{
Scannersc=newScanner(System.in);
while(sc.hasNext()){
intt=sc.nextInt();
for(inti=1;i<=t;i++){
intn=sc.nextInt();
intm=sc.nextInt();
sc.nextLine();
String[]ips=newString[4];
String[]masks=newString[4];
int[]ipToInt=newint
;
for(intj=0;j<n;j++){
ips=sc.nextLine().split("\\.");
//这种写法比较好
for(Stringip:ips){
ipToInt[j]=(ipToInt[j]<<8)+Integer.valueOf(ip);
}
}
System.out.println("Case#"+i+":");
int[]ans=newint[m];
for(intj=0;j<m;j++){
masks=sc.nextLine().split("\\.");
//这种写法必须加括号
intmaskToInt=(Integer.valueOf(masks[0])<<24)+
(Integer.valueOf(masks[1])<<16)+
(Integer.valueOf(masks[2])<<8)+
(Integer.valueOf(masks[3]));
Set<Integer>set=newHashSet<Integer>();
for(intk=0;k<n;k++){
set.add(ipToInt[k]&maskToInt);
}
ans[j]=set.size();
}
for(intj=0;j<m;j++){
System.out.println(ans[j]);
}
}
}
}
}

1002列变位法解密

4
159263748
4
Hwdoeetrrlloellcadoomm!,myew
7
Toodmingisbest
16
sokaisan
1

Case#1:
123456789
Case#2:
Hello,welcometomydreamworld!
Case#3:
Toodmingisbest
Case#4:
sokaisan

思路：属于一看题就知道大概的思路的，但是bug-free对于我来说写起来还有难度。调试了好多遍才成功，边界情况处理的不是很好，暂时不想再研究了，好歹也是过了。
值得注意的地方是StringBuilder的使用，如果是直接新建一个String的话，会超时。

importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;publicclassMain{
publicstaticvoidmain(String[]args)throwsIOException{
InputStreamReaderisr=newInputStreamReader(System.in);
BufferedReaderbr=newBufferedReader(isr);
Stringstr="";
while((str=br.readLine())!=null){
intt=Integer.parseInt(str);
for(inti=1;i<=t;i++){
Strings=br.readLine();
intk=Integer.parseInt(br.readLine());
if(k>=s.length()||k==1){
System.out.println("Case#"+i+":");
System.out.println(s);
}else{
intmod=s.length()%k;
introw=s.length()/k;
if(mod!=0){
row++;
}else{
mod=k;
}
intj=0,p=0,l=0;
StringBuildersb=newStringBuilder();
while(p<row){
l=0;
while(l<=mod){
sb.append(s.charAt(l*row+p));
j=l*row+p;
l++;
if(l==mod&&(p==row-1||mod==k))
break;
}
if(sb.length()==s.length())
break;
while((j+row-1<s.length())&&(mod!=k)){
sb.append(s.charAt(j+row-1));
j=j+row-1;
}
p++;
}
System.out.println("Case#"+i+":");
System.out.println(sb.toString());
}
}
}
}
}

1001大搬家

2
1
3

Case#1:
1
Case#2:
4思路：直接想的可能是怎么才能搬家三次的结果和搬家一次的结果相同，但是实际上可以简化为搬家两次的结果和搬家之前相同。
要出现这样的情况，那第一次搬家i-j必须满足i==j或者i-j&&j-i(i!=j).
当给定为N个人搬家时有ans
种满足条件的可能，假设第一个人是1-1，也就是位置不变，那么剩下的人可能的情况就是ans[N-1]种。
当第一个人是1-j(j!=1)时，那么必定有j-1。所以还剩下N-2个人，所以就是ans[N-2]，又因为此时j有N-1(2-N)种可能。
可得出dp公式ans
=ans[N-1]+(N-1)*ans[N-2];
初始值ans[1]=1；ans[2]=2;利用递归或者dp即可解决，但是递归会超时，dp才是正道。

importjava.util.Scanner;publicclassMain{
publicstaticvoidmain(String[]args){
Scannersc=newScanner(System.in);
while(sc.hasNext()){
intt=sc.nextInt();
long[]ans=newlong[1000001];
longmod=1000000007l;
ans[1]=1;
ans[2]=2;
intm=3;
for(inti=1;i<=t;i++){
intn=sc.nextInt();
while(m<=n){
ans[m]=mod(ans[m-1]+(m-1)*ans[m-2]);//用mod函数会稍微快点，但是不影响结果
m++;
}
System.out.println("Case#"+i+":");
System.out.println(ans
);
//　　　　System.out.println("Case#"+i+":\n"+ans
);//这种形式会报格式错误
}
}
}
publicstaticlongmod(longi){
returni%1000000007;
}
}/**TLE递归影响时间,改成dppublicstaticintfind(intn){
if(n==1)
return1;
if(n==2)
return2;
else
returnmod(find(n-1))+mod((n-1)*find(n-2));
}
*/