1.標題：國王的遺產
  X國是個小國。國王K有6個兒子。在臨終前，K國王立下遺囑：國王的一批牛作為遺產要分給他的6個兒子。
    其中，大兒子分1/4，二兒子1/5，三兒子1/6，....
    直到小兒子分1/9。
    牛是活的，不能把一頭牛切開分。
    最後還剩下11頭牛，分給管家。
    請計算國王這批遺產中一共有多少頭牛。
    這是一個整數，請通過瀏覽器提交答案，不要填寫任何多餘的內容（比如說明性的文字）

    思路：直接暴力

我的答案：2520

public class Main{
	public static void main(String[] args) {
		int n = 20;
		int temp;
		while(true){
			if(n % 4 == 0 && n % 5 == 0 && n % 6 == 0 && n % 7 == 0 && n % 8 == 0 && n % 9 == 0){
				temp = n - n/4 - n/5 - n/6 - n/7 -n/8 - n/9;
				if(temp == 11) {
					System.out.println(n);
					return;
				}else{
					n++;
				}
			}else {
				n++;
			}
			
		}
	}
}
 

2.標題：六角幻方
 把 1 2 3 ... 19 共19個整數排列成六角形狀，如下：
    * * *
   * * * *
  * * * * *
   * * * * 
    * * *
   要求每個直線上的數字之和必須相等。共有15條直線哦！

   再給點線索吧！我們預先填好了2個數字，第一行的頭兩個數字是：15 13，參見圖【p1.png】，黃色一行為所求。

   請你填寫出中間一行的5個數字。數字間用空格分開。

   這是一行用空格分開的整數，請通過瀏覽器提交答案，不要填寫任何多餘的內容（比如說明性的文字等）

思路：dfs

我的答案：9 6 5 2 16 

public class Main{
	static int table[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
	public static void main(String[] args) {
		int arr[] = new int[17];
		boolean step[] = new boolean[20];
		step[15] = step[13] = true;
		dfs(arr, 0, step);
	}
	public static void dfs(int[] arr, int ws, boolean[] step) {
		if(ws == 5) {
			if(28 + arr[0] != arr[1] + arr[2] + arr[3] + arr[4]){
				return ;
			}
		}
		if(ws == 6) {
			if(28 + arr[0] != 15 + arr[1] + arr[5]) {
				return;
			}
		}
		if(ws == 10) {
			if(28 + arr[0] != arr[5] + arr[6] + arr[7] + arr[8] + arr[9])return;
			if(28 + arr[0] != arr[0] + arr[4] + arr[9]) return ;
		}
		if(ws == 11) {
			if(28 + arr[0] != 13 + arr[2] + arr[6] + arr[10]) return;
		}
		if(ws == 14) {
			if(28 + arr[0] != arr[10] + arr[11] + arr[12] + arr[13])return;
			if(28 + arr[0] != 13 + arr[3] + arr[8] + arr[13]) return;
		}
		if(ws == 15) {
			if(28 + arr[0] != arr[5] + arr[10] + arr[14]) return;
			if(28 + arr[0] != arr[0] + arr[3] + arr[7] + arr[11] + arr[14])return;
		}
		  if (ws == 17)  
	        {  
	            if (28 + arr[0] != arr[14] + arr[15]+arr[16]) return;  
	            if (28 + arr[0] !=15+ arr[2]+arr[7] + arr[12]+arr[16]) return;  
	            if (28 + arr[0] != arr[9] + arr[13] + arr[16]) return;  
	              
	            output(arr);return;  
	        }  
		  for(int i = 0; i < table.length; i++) {
			  if(step[table[i]] == false) {
				  step[table[i]] = true;
				  arr[ws] = table[i];
				  dfs(arr, ws + 1, step);
				  step[table[i]] = false;
			  }
		  }
	}
	public static void output(int[] arr) {
		for(int i = 5; i <= 9; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}
}
 

3.標題：格子放雞蛋
   X星球的母雞很聰明。它們把蛋直接下在一個 N * N 的格子中，每個格子只能容納一枚雞蛋。它們有個習慣，要求：每行，每列，以及每個斜線上都不能有超過2個雞蛋。如果要滿足這些要求，母雞最多能下多少蛋呢，有多少種擺放方法呢？
    下面的程式解決了這個問題，請仔細分析程式邏輯，推斷劃線處缺少的程式碼。
public class A
{
static int max = 0;
static int T = 0;
static final int N = 6;

// 只能在(r,c) 以及其右，其下放置 
static void f(int[][] da, int r, int c)
{
if(r>=N){
int n = count(da);
if(n>max) {
max = n;
T = 0;
}
if(n==max) T++;
return;
}

//計算一下步放哪
int r_next = r;
int c_next = c + 1;
if(c_next>=N){
c_next = 0;
r_next++;
}

if(____________________){  // 填空位置
da[r][c] = 1;
f(da, r_next, c_next); 
}

da[r][c] = 0;
f(da, r_next, c_next);
}

static int count(int[][] da)
{
int n = 0;

for(int i=0; i<da.length; i++)
for(int j=0; j<da[i].length; j++) 
if(da[i][j]==1) n++;

return n;
}

static int spy(int[][] da, int r, int c)
{
int m=0;

// 該行
int n=0;
for(int i=0; i<N; i++) if(da[r][i]==1) n++;
if(n>m) m = n;


//該列
n=0;
for(int i=0; i<N; i++) if(da[i][c]==1) n++;
if(n>m) m = n;

//右斜線
n=0;
for(int i=0; i<N; i++){ 
if(r-i<0 || c-i<0) break; 
if(da[r-i][c-i]==1) n++;
}
for(int i=1; i<N; i++){ 
if(r+i>=N || c+i>=N) break; 
if(da[r+i][c+i]==1) n++;
}
if(n>m) m = n;

//左斜線
n=0;
for(int i=0; i<N; i++){ 
if(r-i<0 || c+i>=N) break; 
if(da[r-i][c+i]==1) n++;
}
for(int i=1; i<N; i++){ 
if(r+i>=N || c-i<0) break; 
if(da[r+i][c-i]==1) n++;
}
if(n > m) m = n;

return m;
}

public static void main(String[] args)
{
int[][] da = new int[N][N];

f(da, 0, 0);

System.out.println(max);
System.out.println(T);
}
}

注意：通過瀏覽器提交答案。只填寫缺少的內容，不要填寫任何多餘的內容（例如：說明性文字或已有符號）。

答案： spy(da, r, c) <= 1
 12  1097

4.標題：排列序數
如果用a b c d這4個字母組成一個串，有4!=24種，如果把它們排個序，每個串都對應一個序號：
  abcd  0
  abdc  1
  acbd  2
  acdb  3
  adbc  4
  adcb  5
  bacd  6
  badc  7
  bcad  8
  bcda  9
  bdac  10
  bdca  11
  cabd  12
  cadb  13
  cbad  14
  cbda  15
  cdab  16
  cdba  17
  ...
    現在有不多於10個兩兩不同的小寫字母，給出它們組成的串，你能求出該串在所有排列中的序號嗎？
【輸入格式】
一行，一個串。
【輸出格式】
一行，一個整數，表示該串在其字母所有排列生成的串中的序號。注意：最小的序號是0。
例如：
輸入：
bdca
程式應該輸出：
11
再例如：
輸入：
cedab
程式應該輸出：
70
資源約定：
峰值記憶體消耗（含虛擬機器） < 256M
CPU消耗  < 1000ms

思路：先對輸入的序列按字典序進行排序，然後根據該序列進行dfs全排,再判斷

import java.util.Arrays;
import java.util.Scanner;

public class Main
{
	public static char[] array;
	public static boolean flag[];
	public static char[] all_p;
	public static int count = 0;
	
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String string = in.next();
		array = string.toCharArray();
		Arrays.sort(array);
		//System.out.println(String.valueOf(array));
		flag = new boolean[array.length];
		all_p = new char[array.length];
		dfs(0, string);
	}
	public static void dfs(int n, String string) {
		if(n == array.length) {
			//System.out.println(String.valueOf(all_p));
			if(string.equals(String.valueOf(all_p))){
				System.out.println(count);
			}
			count++;
			return;
		}
		
		for(int i = 0; i < array.length; i++) {
			if(!flag[i]){
				flag[i] = true;
				all_p[n] = array[i];
				dfs(n + 1, string);
				flag[i] = false;
			}
		}
		
	}
}

5.標題：冪一矩陣
    天才少年的鄰居 atm 最近學習了線性代數相關的理論，他對“矩陣”這個概念特別感興趣。矩陣中有個概念叫做冪零矩陣。對於一個方陣 M ，如果存在一個正整數 k 滿足 M^k = 0 ，那麼 M 就是一個冪零矩陣。（^ 表示乘方）
    atm 不滿足冪零矩陣，他自己設想了一個冪一矩陣：對於一個方陣 M ，如果存在一個正整數 k 滿足 M^k = I ，其中 I 是單位矩陣，那麼 M 就是一個冪一矩陣。
    atm 特別鍾情於這樣一種方陣：每行每列有且僅有一個 1 。經過 atm 不斷實驗，他發現這種矩陣都是冪一矩陣。
   現在，他的問題是，給定一個滿足以上條件的方陣，他想求最小的 k 是多少。
【輸入格式】
第一行一個正整數 n ，表示矩陣大小是 n * n 。
接下來 n 行，每行兩個正整數 i j 表示方陣的第 i 行第 j 列為 1。
1 <= i, j <= n 。
行號，列號都從1開始。
【輸出格式】
一行。一個正整數，即題目中所說最小的 k 。
【樣例輸入】
5
3 1
1 2
4 4
2 3
5 5
【樣例輸出】
3
【資料範圍】
對於 30% 的資料滿足 n <= 10 
對於 60% 的資料答案不超過 10^18 
對於 100% 的資料滿足 n <= 10000

資源約定：
峰值記憶體消耗（含虛擬機器） < 256M
CPU消耗  < 1000ms

    

6.標題：供水設施

 X星球的居民點很多。Pear決定修建一個浩大的水利工程，以解決他管轄的N個居民點的供水問題。現在一共有N個水塔，同時也有N個居民點，居民點在北側從1號到N號自西向東排成一排；水塔在南側也從1號到N號自西向東排成一排。
    N條單向輸水線（有水泵動力），將水從南側的水塔引到北側對應的居民點。
    我們不妨將居民點和水塔都看做平面上的點，居民點座標為(1,K)~(N,K)，水塔為(1,0)~(N,0)。
    除了N條縱向輸水線以外，還有M條單向的橫向輸水線，連線(Xi,Yi)和(Xi,(Yi)+1)或者(Xi,Yi)和(Xi,(Yi)-1)。前者被稱為向右的水路，而後者是向左的。不會有兩條水路重疊，即便它們方向不同。

    佈局的示意圖如：【p1.png】所示。

    顯然，每個水塔的水都可以到達若干個居民點（而不僅僅是對應的那個）。例如上圖中，4號水塔可以到達3、4、5、6四個居民點。
 現在Pear決定在此基礎上，再修建一條橫向單項輸水線。為了方便考慮，Pear認為這條水路應當是自左向右的，也就是連線了一個點和它右側的點（例如上圖中連線5和6兩個縱線的橫向水路）。
    Pear的目標是，修建了這條水路之後，能有儘可能多對水塔和居民點之間能到達。換句話說，設修建之後第i個水塔能到達Ai個點，你要最大化A1+A2+...+An。
    根據定義，這條路必須和X軸平行，但Y座標不一定要是整數。注意：雖然輸入中沒有重疊的水路，但是你的方案可以將新修的輸水線路與已有的水路重疊。
【輸入資料】
    輸入第一行包含三個正整數N，M，K，含義如題面所述：N是縱向線數，M橫向線數，K是居民點縱座標。
    接下來M行，每行三個整數。前兩個正整數Xi Yi表示水路的起點座標；
    1<=Xi<=N,0<Yi<K。
    接下來一個數0或者1，如果是0表示這條水路向左，否則向右。
    保證水路都是合法的，也就是不會流向沒有定義的地方。
【輸出資料】
輸出一行。是一個正整數，即：題目中要求的最大化的A1+A2+...+An。
【輸入樣例1】
4 3 2
1 1 1
3 1 0
3 1 1
【輸出樣例1】
11
【輸入樣例2】
7 9 4
2 3 0
7 2 0
6 3 1
6 1 0
2 1 1
3 3 1
5 2 0
2 2 1
7 1 0
【輸出樣例2】
21
【資料範圍】
對於20%的資料，N,K<=20，M<=100
對於40%的資料，N,K<=100，M<=1000
對於60%的資料，N,K<=1000，M<=100000
對於100%的資料，N,K<=50000，M<=100000

資源約定：
峰值記憶體消耗（含虛擬機器） < 256M

CPU消耗  < 5000ms