NYOJ-990蚂蚁感冒

长100厘米的细长直杆子上有n只蚂蚁。它们的头有的朝左，有的朝右。

 

    每只蚂蚁都只能沿着杆子向前爬，速度是1厘米/秒。

 

    当两只蚂蚁碰面时，它们会同时掉头往相反的方向爬行。

 

    这些蚂蚁中，有1只蚂蚁感冒了。并且在和其它蚂蚁碰面时，会把感冒传染给碰到的蚂蚁。

 

    请你计算，当所有蚂蚁都爬离杆子时，有多少只蚂蚁患上了感冒。

 

 

【数据格式】

 

    第一行输入一个整数n (1 < n < 50), 表示蚂蚁的总数。

 

    接着的一行是n个用空格分开的整数 Xi (-100 < Xi < 100), Xi的绝对值，表示蚂蚁离开杆子左边端点的距离。正值表示头朝右，负值表示头朝左，数据中不会出现0值，也不会出现两只蚂蚁占用同一位置。其中，第一个数据代表的蚂蚁感冒了。

 

    要求输出1个整数，表示最后感冒蚂蚁的数目。

 

例如，输入：

3

5 -2 8

程序应输出：

1

 

再例如，输入：

5

-10 8 -20 12 25

程序应输出：

3

思路：虽然网上有把碰撞当穿过来考虑，确实好厉害。但是也拿上自己的比较普通的想法。

1、先是写个写个新类，继承Comparable。这是为了可以通过Arrays.sort(可以放对象，但是必须继承comparable)。

2、然后通过Arrays.sort进行排序。这里我的比较方式是，按数字的绝对值进行排序。不按正常排序的方式

3、分析碰撞情况：总结后有两种，例如（1，-3）的情况。再运行一次会相等。

                                                      第二种：（1，-2），这一种是运行完后变成（-1,2），这是刚刚是2的绝对值变成绝对值是1。刚刚1的绝对值现在是2.也就是后者小于前者。

4、接下来就是步骤：1、先进行所有数据的判断，是否发生碰撞。在写一个for循环让所有的动一次，最后判断时候都动完。

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






public class Main {
	//思路：首先是先把录入的数据先拍好序，然后先让蚂蚁动完，然后对于碰撞的两种情况进行分析
	
	static Scanner scan=new Scanner(System.in);

	public static void main(String[] args){
		
		Main test=new Main();
		while(scan.hasNext()){
			test.start();
		}
		
	}

	public void start(){
		
		int a=scan.nextInt();
		A[] a1=new A[a];
		for(int i=0;i<a;i++){
			
			a1[i]=new A(scan.nextInt());
			
		}
		a1[0].b=1;
		Arrays.sort(a1);//有相等和现在的小于前一个
		while(true){
			for(int i=0;i<a1.length;i++){
				//检测相等的时候
				
				if(i!=0){
					if(Math.abs(a1[i].a)<Math.abs(a1[i-1].a)){
						if(a1[i].b==1||a1[i-1].b==1){
							a1[i-1].b=1;
							a1[i].b=1;
						}
						int temp=a1[i].a;
						a1[i].a=a1[i-1].a;
						a1[i-1].a=temp;
						
					}
					
					if(Math.abs(a1[i].a)==Math.abs(a1[i-1].a)){
						if(a1[i].a!=0&&a1[i].a!=100){
							if(a1[i].b==1||a1[i-1].b==1){
								a1[i-1].b=1;
								a1[i].b=1;
							}
							
							a1[i].a=-a1[i].a;
							a1[i-1].a=-a1[i-1].a;
						}
					}
				}
				
				
				
				
				
			}
			for(int i=0;i<a1.length;i++){
				//开始行动
				if(a1[i].a<0){
					a1[i].a+=1;
				}else{
					if(a1[i].a>0&&a1[i].a<=99){
						a1[i].a+=1;
					}
				}
				
			}
			if(isTrue(a1)){
				break;
			}
			
		}
		int sum=0;
		for(int i=0;i<a1.length;i++){
			
			if(a1[i].b==1){
				sum++;
			}
			
		}
		System.out.println(sum);
		
		
	}
	
	public boolean isTrue(A[] a){
		
		for(int i=0;i<a.length;i++){
			
			if(a[i].a==0||a[i].a==100){
				
			}else{
				return false;
			}
			
		}
		return true;
	}
	
}

class A implements Comparable<A>{
	int a;
	int b;
	
	public A(int a){
		this.a=a;
		
	}
	
	

	@Override
	public String toString() {
		
		return a+"";
	}



	@Override
	public int compareTo(A o) {
		A a1=o;
		int a2=Math.abs(a1.a);
		int a3=Math.abs(a);
		if(a3==a2){
			return 0;
		}else{
			if(a3>a2){
				return 1;
			}else{
				return -1;
			}
		}
		
	}
	
	
	
}

还有另外一种在网上看来的方法，自己理解了一下。虽然还是不理解把爬过看成穿行是什么意思。

public class Main {
	
static Scanner scan=new Scanner(System.in);
	
	//穿过方法，1、这个数的左边，这个数的右边、相加。
	
	public static void main(String[] args){
		
		Main test=new Main();
		test.start();
		
	}
	
	public void start(){
		
		int a=scan.nextInt();
		int n=scan.nextInt();
		int sum=1;
		int right=0;
		int left=0;
		for(int i=1;i<a;i++){
			int c=scan.nextInt();
			//它左边
			if(Math.abs(c)<Math.abs(n)){
				
				if(c>0){
					left++;
				}
				
			}else{
				if(c<0){
					right++;
				}
			}
			
			
		}
		if(n>0){
			if(right!=0){
				sum+=right+left;
			}
		}else{
			if(left!=0){
				
				sum+=left+right;
				
			}
		}
		System.out.println(sum);
	}
	
}