螞蟻感冒 長100釐米的細長直杆子上有n只螞蟻。它們的頭有的朝左，有的朝右。每隻螞蟻都只能沿着杆子向前爬，速度是1釐米/秒。當兩隻螞蟻碰面時，它們會同時掉頭往相反的方向爬行。這些螞蟻中，有1只螞蟻感冒了。並且在和其它螞蟻碰面時，會把感冒傳染給碰到的螞蟻。請你計算，當所有螞蟻都爬離杆子時，有多少隻螞蟻患上了感冒。【數據格式】第一行輸入一個整數n (1 < n < 50), 表示螞蟻的總數。接着的一行是n個用空格分開的整數 Xi (-100 < Xi < 100), Xi的絕對值，表示螞蟻離開杆子左邊端點的距離。正值表示頭朝右，負值表示頭朝左，數據中不會出現0值，也不會出現兩隻螞蟻佔用同一位置。其中，第一個數據代表的螞蟻感冒了。要求輸出1個整數，表示最後感冒螞蟻的數目。例如，輸入：35 -2 8程序應輸出：1再例如，輸入：5-10 8 -20 12 25程序應輸出：3
假設A有感冒 A左邊向右走的螞蟻數目爲lf A右邊向左走的數目爲rg
那麼最後感染的螞蟻數目就是 if+rg+自身
package 訓練;
import java.util.Iterator;
import java.util.Scanner;
import java.util.TreeSet;
public class 螞蟻感冒
{
static int N;
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
N = scanner.nextInt();
TreeSet<Ant> treeSet = new TreeSet<>();
Ant firstant = null;
for (int i = 0; i < N; i++)
{
int a = scanner.nextInt();
int dis = a > 0 ? 1 : -1;
int cold = 0;
Ant ant = null;
if (i == 0)
{
cold = 1;// 第一隻感冒
ant = new Ant(Math.abs(a), dis, cold);
firstant = ant;
} else
{
ant = new Ant(Math.abs(a), dis, cold);
}
treeSet.add(ant);
}
int lf = 0, rg = 0;
int i = 0;
boolean flag = false;
for (Iterator iterator = treeSet.iterator(); iterator.hasNext();)
{
Ant ant = (Ant) iterator.next();
if (ant.cold == 1)
{
flag = true;
continue;
}
if (ant.dis > 0 && !flag)// 左邊頭向右
{
lf++;
} else if (ant.dis < 0 && flag)// 右邊向左
{
rg++;
}
i++;
}
System.out.println(lf + rg + 1);
}
}
class Ant implements Comparable<Ant>
{
int pos;// 螞蟻的位置（絕對值）
int dis;// 螞蟻的方向（-1，左 1，右）
int cold;// 感冒標識
public Ant(int pos, int dis, int cold)
{
super();
this.pos = pos;
this.dis = dis;
this.cold = cold;
}
@Override
public int compareTo(Ant o)
{
return this.pos - o.pos;
}
@Override
public String toString()
{
return "Ant [pos=" + pos + ", dis=" + dis + ", cold=" + cold + "]";
}
}搭積木
小明最近喜歡搭數字積木。一共有10塊積木，每個積木上有一個數字，0~9。
搭積木規則：
每個積木放到其它兩個積木的上面，並且一定比下面的兩個積木數字小。
最後搭成4層的金字塔形，必須用完所有的積木。
下面是兩種合格的搭法：
0
1 2
3 4 5
6 7 8 9
0
3 1
7 5 2
9 8 6 4
請你計算這樣的搭法一共有多少種？
用數組的框架 改變最後條件即可
package 訓練;
public class 搭積木
{
static int count;
public static void main(String[] args)
{
//排列問題
int []arr={0,1,2,3,4,5,6,7,8,9};
f(arr,0);
System.out.println(count);
}
private static void f(int[] arr, int i)
{
if (i==arr.length)
{
if (check(arr))
{
count++;
}
return;
}
for (int j = i; j < arr.length; j++)
{
int temp=arr[j];arr[j]=arr[i];arr[i]=temp;
f(arr, i+1);
temp=arr[j];arr[j]=arr[i];arr[i]=temp;
}
}
private static boolean check(int[] arr)
{
if (
arr[0]<arr[1]&&
arr[0]<arr[2]&&
arr[1]<arr[3]&&
arr[1]<arr[4]&&
arr[2]<arr[4]&&
arr[2]<arr[5]&&
arr[3]<arr[6]&&
arr[3]<arr[7]&&
arr[4]<arr[7]&&
arr[4]<arr[8]&&
arr[5]<arr[8]&&
arr[5]<arr[9]
)
{
return true;
}
return false;
}
}
X星球要派出一個5人組成的觀察團前往W星。
其中：
A國最多可以派出4人。
B國最多可以派出2人。
C國最多可以派出2人。
D國最多可以派出1人。
E國最多可以派出1人。
F國最多可以派出3人。
那麼最終派往W星的觀察團會有多少種國別的不同組合呢？
package 經典的遞歸框架;
public class 組合X星球要派出一個5人組成的觀察團前往W星
{
/**
* X星球要派出一個5人組成的觀察團前往W星。
其中：
A國最多可以派出4人。
B國最多可以派出2人。
C國最多可以派出2人。
D國最多可以派出1人。
E國最多可以派出1人。
F國最多可以派出3人。
那麼最終派往W星的觀察團會有多少種國別的不同組合呢？
* @param args
*/
static int count=0;
public static void main(String[] args)
{
int[] data={4,2,2,1,1,3};//每個位置的元素最多取個數
int x[]=new int[data.length];//每個元素取幾個
int n=5;
f4(data,x,0,n);
System.out.println(count);
}
/**
*
* @param data 每個位置的元素最多取個數
* @param x 取法
* @param k 當前位置
* @param goal 還要取得個數
*/
private static void f4(int[] data, int[] x, int k, int goal)
{
if (k==x.length)
{
if (goal==0)
{
printQueue(x);
count++;
}
return;
}
for (int i = 0; i <= Math.min(goal, data[k]); i++)
{ //最多能取多少
x[k]=i;//取幾個
f4(data, x, k+1, goal-i);
}
x[k]=0;//回溯
}
private static void printQueue(int[] x)
{
StringBuffer stringBuffer=new StringBuffer();
for (int i = 0; i < x.length; i++)
{
for (int j = 0; j < x[i]; j++)
{
stringBuffer.append((char)(i+'A')+" ");
}
}
System.out.println(stringBuffer.toString().trim());
}
}
