topcoder srm 315 div1

problem1 link

直接模拟即可。

import java.util.*;
import java.math.*;
import static java.lang.Math.*;

public class DigitsSum {

public int lastDigit(int n) {
while(n>=10) {
int s=0;
while(n!=0) {
s+=n%10;
n/=10;
}
n=s;
}
return n;
}
}

　problem2 link

暴力搜索，记忆搜过的状态。

import java.util.*;
import java.math.*;
import static java.lang.Math.*;

public class SillySudoku {

Map<Long,Integer> map=null;

long gethash(Integer[][] a) {
long x=0;
for(int i=0;i<4;++i) {
for(int j=0;j<4;++j) {
x=x*10+a[i][j];
}
}
return x;
}

boolean check(Integer[][] a,int x,int y) {
for(int i=0;i<4;++i) {
if(i!=y&&a[x][i]==a[x][y]) {
return false;
}
if(i!=x&&a[i][y]==a[x][y]) {
return false;
}
}
for(int i=x/2*2;i<x/2*2+2;++i) {
for(int j=y/2*2;j<y/2*2+2;++j) {
if(i==x&&j==y) continue;
if(a[x][y]==a[i][j]) {
return false;
}
}
}
return true;
}

int dfs(Integer[][] a,int x,int y) {
if(y==4) {
++x;
y=0;
}
if(x==4) {
return 1;
}
long h=gethash(a);
if(map.containsKey(h)) {
return map.get(h);
}
if(a[x][y]!=0) {
int result=check(a,x,y)?dfs(a,x,y+1):0;
map.put(h,result);
return result;
}

int result=0;

for(int i=1;i<=4;++i) {
a[x][y]=i;
if(check(a,x,y)) {
result+=dfs(a,x,y+1);
}
a[x][y]=0;
}
map.put(h,result);
return result;
}

public int countWays(String[] board) {
map=new HashMap<>();

Integer[][] a=new Integer[4][4];
for(int i=0;i<4;++i) {
for(int j=0;j<4;++j) {
if(board[i].charAt(j)=='-') {
a[i][j]=0;
}
else {
a[i][j]=(int)(board[i].charAt(j)-'0');
}
}
}

return dfs(a,0,0);
}
}

problem3 link

三个矩形的位置有六种情况：

（1）右侧一个，左侧上下两个；

（2）左侧一个，右侧上下两个；

（3）左中右三个；

（4）上面左右两个，下面一个；

（5）上面一个，下面左右两个；

（6）上中下三个。

所以预处理并保存以(i,j)为右下角，左下角，右上角，左上角的区域内可选出的最优矩形，这样就能轻松地解决（1）（2）（4）（5）四种情况。对于第（3）（6）两种情况，首先枚举两条分界线，分界线中间的这一块不能直接得到结果，只能暴力。所以最大的复杂度是$30^{4}$

import java.util.*;
import java.math.*;
import java.util.regex.Matcher;

import static java.lang.Math.*;

public class ThreeMines {

int n,m;
int[][] a=null;
int[][] b=null;

int[][] rb=null;
int[][] lb=null;
int[][] lu=null;
int[][] ru=null;

int max(int ...a) {
int ans=Integer.MIN_VALUE;
for(int i=0;i<a.length;++i) {
ans=Math.max(ans,a[i]);
}
return ans;
}

int calsum(int x0,int y0,int x1,int y1) {
return b[x1][y1]-b[x1][y0-1]-b[x0-1][y1]+b[x0-1][y0-1];
}

void calrb() {
rb=new int[n+1][m+1];
for(int i=1;i<=n;++i) {
for(int j=1;j<=m;++j) {
rb[i][j]=Integer.MIN_VALUE;
for(int x=1;x<=i;++x) {
for(int y=1;y<=j;++y) {
rb[i][j]=max(rb[i][j],calsum(x,y,i,j));
}
}
if(i>1) rb[i][j]=max(rb[i][j],rb[i-1][j]);
if(j>1) rb[i][j]=max(rb[i][j],rb[i][j-1]);
}
}
}

void callb() {
lb=new int[n+1][m+1];
for(int i=1;i<=n;++i) {
for(int j=m;j>=1;--j) {
lb[i][j]=Integer.MIN_VALUE;
for(int x=1;x<=i;++x) {
for(int y=m;y>=j;--y) {
lb[i][j]=max(lb[i][j],calsum(x,j,i,y));
}
}
if(i>1) lb[i][j]=max(lb[i][j],lb[i-1][j]);
if(j<m) lb[i][j]=max(lb[i][j],lb[i][j+1]);
}
}
}
void callu() {
lu=new int[n+1][m+1];
for(int i=n;i>=1;--i) {
for(int j=m;j>=1;--j) {
lu[i][j]=Integer.MIN_VALUE;
for(int x=n;x>=i;--x) {
for(int y=m;y>=j;--y) {
lu[i][j]=max(lu[i][j],calsum(i,j,x,y));
}
}
if(i<n) lu[i][j]=max(lu[i][j],lu[i+1][j]);
if(j<m) lu[i][j]=max(lu[i][j],lu[i][j+1]);
}
}
}

void calru() {
ru=new int[n+1][m+1];
for(int i=n;i>=1;--i) {
for(int j=1;j<=m;++j) {
ru[i][j]=Integer.MIN_VALUE;
for(int x=n;x>=i;--x) {
for(int y=1;y<=j;++y) {
ru[i][j]=max(ru[i][j],calsum(i,y,x,j));
}
}
if(i<n) ru[i][j]=max(ru[i][j],ru[i+1][j]);
if(j>1) ru[i][j]=max(ru[i][j],ru[i][j-1]);
}
}
}

int cal1() {
int ans=Integer.MIN_VALUE;
for(int j=1;j<m;++j) {
for(int i=1;i<n;++i) {
ans=max(ans,rb[i][j]+ru[i+1][j]+lb
[j+1]);
}
}
return ans;
}
int cal2() {
int ans=Integer.MIN_VALUE;
for(int j=1;j<m;++j) {
for(int i=1;i<n;++i) {
ans=max(ans,rb
[j]+lb[i][j+1]+lu[i+1][j+1]);
}
}
return ans;
}
int cal3() {
int ans=Integer.MIN_VALUE;
for(int i=1;i<m;++i) {
for(int j=i+1;j<m;++j) {
int premax=Integer.MIN_VALUE;
for(int k=1;k<=n;++k) {
for(int x=1;x<=k;++x) {
premax=max(premax,calsum(x,i+1,k,j));
}
}
ans=max(ans,rb
[i]+premax+lb
[j+1]);
}
}
return ans;
}
int cal4() {
int ans=Integer.MIN_VALUE;
for(int i=1;i<n;++i) {
for(int j=1;j<m;++j) {
ans=max(ans,rb[i][j]+lb[i][j+1]+ru[i+1][m]);
}
}

return ans;
}
int cal5() {
int ans=Integer.MIN_VALUE;
for(int i=1;i<n;++i) {
for(int j=1;j<m;++j) {
ans=max(ans,rb[i][m]+ru[i+1][j]+lu[i+1][j+1]);
}
}
return ans;
}

int cal6() {
int ans=Integer.MIN_VALUE;
for(int i=1;i<n;++i) {
for(int j=i+1;j<n;++j) {
int premax=Integer.MIN_VALUE;
for(int k=1;k<=m;++k) {
for(int y=1;y<=k;++y) {
premax=max(premax,calsum(i+1,y,j,k));
}
}
ans=max(ans,rb[i][m]+premax+ru[j+1][m]);
}
}
return ans;
}

public int maximumProfit(String[] field) {
n=field.length;
m=field[0].length();
a=new int[n+1][m+1];
for(int i=0;i<n;++i) {
for(int j=0;j<m;++j) {
char c=field[i].charAt(j);
if('a'<=c&&c<='z') {
a[i+1][j+1]=(int)(c-'a');
}
else {
a[i+1][j+1]=(int)('A'-c);
}
}
}
b=new int[n+1][m+1];
for(int i=1;i<=n;++i) {
for(int j=1;j<=m;++j) {
b[i][j]=b[i-1][j]+b[i][j-1]-b[i-1][j-1]+a[i][j];
}
}
calrb();
callb();
callu();
calru();
int ans=Integer.MIN_VALUE;
ans=max(ans,cal1());
ans=max(ans,cal2());
ans=max(ans,cal3());
ans=max(ans,cal4());
ans=max(ans,cal5());
ans=max(ans,cal6());
return ans;
}
}