第一课：暴力破解与实用性优先

暴力是一种解决非常多问题的常用方法，解决问题之前应当先考虑是否课暴力，并非所有题都可暴力，但是暴力是一个很好的思路。

第一题：年龄谜题

美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。
他曾在1935~1936年应邀来中国清华大学讲学。
一次，他参加某个重要会议，年轻的脸孔引人注目。
于是有人询问他的年龄，他回答说：
“我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字，每个都恰好出现1次。”
请你推算一下，他当时到底有多年轻。

目标：实用、快速、稳定、有效

实用性原则：直接打印i的3次方，4次方，看！！！

public class Main{
    public static void main(String[] args)  {
    	String s1 = "";
    	String s2 = "";
    	for(int i=0;i<=30;++i){
    		s1 = Integer.toString(i*i*i);
    		s2 = Integer.toString(i*i*i*i);
    		if(s1.length()!=4||s2.length()!=6)
    			continue;
    		System.out.println(i+":"+i*i*i+"  "+i*i*i*i);
    	}
    }
}

第二题：罗马数字

古罗马帝国开创了辉煌的人类文明，但他们的数字表示法的确有些繁琐，尤其在表示大数的时候，现在看起来简直不能忍受，所以在现代很少使用了。
之所以这样，不是因为发明表示法的人的智力的问题，而是因为一个宗教的原因，当时的宗教禁止在数字中出现0的概念！
罗马数字的表示主要依赖以下几个基本符号：

I --> 1
V --> 5
X --> 10
L --> 50
C --> 100
D --> 500
M --> 1000

这里，我们只介绍一下1000以内的数字的表示法。
单个符号重复多少次，就表示多少倍。最多重复3次。
比如：CCC表示300  XX表示20，但150并不用LLL表示，这个规则仅适用于I X C M。

如果相邻级别的大单位在右，小单位在左，表示大单位中扣除小单位。
比如：IX表示9  IV表示4  XL表示40 
49 = XLIX
    
更多的示例参见下表，你找到规律了吗？    
I = 1 
II = 2
III = 3
IV = 4
V = 5
VI = 6
VII = 7
VIII = 8
IX = 9 
X = 10
XI = 11
XII = 12
XIII = 13
XIV = 14
XV = 15
XVI = 16
XVII = 17
XVIII = 18
XIX = 19
XX = 20
XXI = 21
XXII = 22
XXIX = 29
XXX = 30
XXXIV = 34
XXXV = 35
XXXIX = 39
XL = 40
L = 50
LI = 51
LV = 55
LX = 60
LXV = 65
LXXX = 80
XC = 90
XCIII = 93
XCV = 95
XCVIII = 98
XCIX = 99
C = 100
CC = 200
CCC = 300
CD = 400
D = 500
DC = 600
DCC = 700
DCCC = 800
CM = 900
CMXCIX = 999

本题目的要求是：请编写程序，由用户输入若干个罗马数字串，程序输出对应的十进制表示。

输入格式是：第一行是整数n,表示接下来有n个罗马数字(n<100)。
以后每行一个罗马数字。罗马数字大小不超过999。
要求程序输出n行，就是罗马数字对应的十进制数据。

例如，用户输入：
3
LXXX
XCIII
DCCII

则程序应该输出：
80
93
702

对于情况可数的问题，完全可以直接暴力。

import java.math.*;
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		int T = cin.nextInt();
		while(T-->0){
			String s = cin.next();
			System.out.println(cal(s));
		}
	}
	public static int cal(String ss){
		int sum = 0;
		for(int i=0;i<ss.length();++i){
			char c = ss.charAt(i);
			if(c=='I') sum += 1;
			if(c=='V') sum += 5;
			if(c=='X') sum += 10;
			if(c=='L') sum += 50;
			if(c=='C') sum += 100;
			if(c=='D') sum += 500;
			if(c=='M') sum += 1000;
		}
		//补偿法
		if(ss.indexOf("IV")>=0)	sum -= 2;  //用indexof判断是否有以下几种情况，pS：罗马数字不会出现IVIV这样的情况
		if(ss.indexOf("IX")>=0)	sum -= 2;
		if(ss.indexOf("XL")>=0)	sum -= 20;
		if(ss.indexOf("XC")>=0)	sum -= 20;
		if(ss.indexOf("CD")>=0)	sum -= 200;
		if(ss.indexOf("CM")>=0)	sum -= 200;
		
		return sum;
	}
}

三：九宫幻方

小明最近在教邻居家的小朋友小学奥数，而最近正好讲述到了三阶幻方这个部分。
三阶幻方指的是将1~9不重复的填入一个3*3的矩阵当中，使得每一行、每一列和每一条对角线的和都是相同的。	
三阶幻方又被称作九宫格，在小学奥数里有一句非常有名的口诀：
“二四为肩，六八为足，左三右七，戴九履一，五居其中”，
通过这样的一句口诀就能够非常完美的构造出一个九宫格来。	
4 9 2
3 5 7
8 1 6
有意思的是，所有的三阶幻方，都可以通过这样一个九宫格进行若干镜像和旋转操作之后得到。
现在小明准备将一个三阶幻方（不一定是上图中的那个）中的一些数抹掉，交给邻居家的小朋友来进行还原，并且希望她能够判断出究竟是不是只有一个解。
	
而你呢，也被小明交付了同样的任务，但是不同的是，你需要写一个程序~

输入格式：
输入仅包含单组测试数据。
每组测试数据为一个3*3的矩阵，其中为0的部分表示被小明抹去的部分。
对于100%的数据，满足给出的矩阵至少能还原出一组可行的三阶幻方。

输出格式：
如果仅能还原出一组可行的三阶幻方，则将其输出，否则输出“Too Many”（不包含引号）。

样例输入
0 7 2
0 5 0
0 3 0

样例输出
6 7 2
1 5 9
8 3 4

思考一下，符合情况的9宫格无非只有八种，只要把这8种可能都列举出来，然后进行对照，判断数量即可。

import java.math.*;
import java.util.*;

public class Main {
	static String ss[] = {
			"492357816",
			"276951438",
			"834159672",
			"618753294",
			"294753618",
			"672159834",
			"438954276",
			"816357492",
	};
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		while(cin.hasNext()){
			String s1 = cin.next();
			String s2 = cin.next();
			String s3 = cin.next();
			String s = s1+s2+s3;
			slove(s);
		}
	}
	public static void slove(String s){
		int cnt = 0;
		String ans_str = "";
		for(int i=0;i<ss.length;++i){
			if(check(ss[i],s)) {
				cnt++;
				ans_str = ss[i];
			}
		}
		if(cnt == 1){
			System.out.println(ans_str.substring(0, 3));
			System.out.println(ans_str.substring(3, 6));
			System.out.println(ans_str.substring(6, 9));
		}
		else 
			System.out.println("Too Many");
	}
	public static boolean check(String str,String s){
		for(int i=0;i<=8;++i){
			if(str.charAt(i)==s.charAt(i)) continue;
			if(s.charAt(i)=='0')	continue;
			return false;
		}
		return true;
	}
}

DFS：

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

int a[10];
int vis[10];
int cnt;

void check(int a[])
{
	int flag = 15;
	if(((a[1]+a[2]+a[3])==flag)&&(a[4]+a[5]+a[6]==flag)&&(a[7]+a[8]+a[9]==flag)&&(a[1]+a[4]+a[7]==flag)&&(a[3]+a[6]+a[9]==flag)&&(a[2]+a[5]+a[8]==flag)&&(a[1]+a[5]+a[9]==flag)&&(a[3]+a[5]+a[7]==flag)){
		printf("\n%d %d %d\n",a[1],a[2],a[3]);
		printf("%d %d %d\n",a[4],a[5],a[6]);
		printf("%d %d %d\n\n",a[7],a[8],a[9]);
		cnt++;
	}
}
void dfs(int step)
{
	if(step == 10){
		check(a);
		return ;
	}
	for(int i=1;i<=9;++i){
		if(vis[i]==0&&a[step]==0){
			vis[i] = 1;
			a[step] = i;
			dfs(step+1);
			vis[i] = 0;
			a[step] = 0;
		}
	}
	dfs(step+1);
}
int main()
{
	cnt = 0;
	for(int i=1;i<=9;++i){
		scanf("%d",&a[i]);
		vis[a[i]] = 1;
	} 
	dfs(1);
	printf("\n%d\n",cnt); 
}