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）两种情况，首先枚举两条分界线，分界线中间的这一块不能直接得到结果，只能暴力。所以最大的复杂度是$n^{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[n][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[n][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[n][i]+premax+lb[n][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;
	}
}