CoderMeng

public class Main1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		while(in.hasNext()){
			String str = in.nextLine();
			String str1 = in.nextLine();
			Main1.match(str, str1);
		}
	}
	
	/**
	 * 统计str1在str中出现的次数
	 * @param str
	 * @param str1
	 */
	public static void match(String str, String str1){
		//p 保存匹配的第一个字符在str 中的位置
		//q 指向后续元素匹配的位置
		int p = 0,q=0;
		//统计一共有多少个匹配
		int count=0;
		char[] strArr = str.toCharArray();
		char[] str1Arr = str1.toCharArray();
		for(int i=0; i<strArr.length; i++){
			if (strArr[i] == str1Arr[q]) {
				//将i的值保存起来
				p = i;
				i++;
				q = 1;
				for ( ; i < strArr.length; i++) {
					if (q < str1Arr.length && strArr[i]==str1Arr[q]) {
						if (q == str1Arr.length-1) {
							count++;
							i = p + q;
							q = 0;
							break;
						}else{
							q++;
							continue;
						}
					}else{
						i = p;
						q = 0;
						break;
					}
				}
			}
		}
		System.out.println(count);
	}
}

public class Main {

	public static int direction(int[] pi, int[] pj, int[] pk){ 
        return (pi[0]-pk[0])*(pi[1]-pj[1]) - (pi[0]-pj[0])*(pi[1]-pk[1]); 
    } 
    /** 
     * 判断点pk是否在线段 pi,pj 上 
     * @return boolean 
     */
    public static boolean onSegment(int[] pi, int[] pj, int[] pk) { 
        if ( Math.min(pi[0], pj[0]) <= pk[0] && pk[0] <= Math.max(pi[0], pj[0]) &&  
             Math.min(pi[1], pj[1]) <= pk[1] && pk[1] <= Math.max(pi[1], pj[1]) ) { 
            return true; 
        }else { 
            return false; 
        } 
    } 
    // 判断线段 p1,p2 和线段 p3,p4 是否相交 
    public static boolean segmentInsert(int[] p1, int[] p2, int[] p3, int[] p4) { 
        int d1 = direction(p3, p4, p1); 
        int d2 = direction(p3, p4, p2); 
        int d3 = direction(p1, p2, p3); 
        int d4 = direction(p1, p2, p4); 
        if ( ((d1>0 && d2<0) || (d1<0 && d2>0)) && 
             ((d3>0 && d4<0) || (d3<0 && d4>0))) { 
            return true; 
        } else if ( d1==0 && onSegment(p3, p4, p1)) { 
            return true; 
        } else if ( d2==0 && onSegment(p3, p4, p2)) { 
            return true; 
        } else if ( d3==0 && onSegment(p1, p2, p3)) { 
            return true; 
        } else if ( d4==0 && onSegment(p1, p2, p4)) { 
            return true; 
        } else { 
            return false; 
        } 
    } 
    
    public static double area(int[] p1, int[] p2, int[] p3){
//    	return (p1[0]*p2[1]+p2[0]*p3[0]*p1[1] - p1[0]*p3[1] - p2[0]*p1[1] - p3[0]*p2[1])/2.0;
    	return Math.abs( Main.direction(p1, p2, p3)/2.0 );
    }
  
    public static void meet(int[] p1, int[] p2, int[] p3,int[] p4, int p5[],int n) {
    	double area = Main.area(p1, p2, p3);
    	System.out.println("Case "+n);
    	System.out.print(area);
    	boolean b1 = segmentInsert(p1, p2, p5, p4);
    	boolean b2 = segmentInsert(p1, p3, p5, p4);
    	boolean b3 = segmentInsert(p3, p2, p5, p4);
    	
    	if (b1 && b2 && b3) {
			System.out.println(" Yes");
		}else{
			System.out.println(" No");
		}
    	
	}
    
    public static void main(String[] args){ 
        Scanner in = new Scanner(System.in);    
        while(in.hasNext()){
        	int n = in.nextInt();
        	for (int i = 1; i <= n; i++) {
        		//三角形三点
        		int[] p1 = {in.nextInt(), in.nextInt()}; 
                int[] p2 = {in.nextInt(), in.nextInt()}; 
                int[] p3 = {in.nextInt(), in.nextInt()};
                int[] p4 = {in.nextInt(), in.nextInt()};
                int[] p5 = {in.nextInt(), in.nextInt()};
                Main.meet(p1, p2, p3, p4, p5, i);
			}
        }
    } 
}

/**
 * @author corlymeng.com
 * @date 2015年10月30日
 */
package com.corlymeng.sort;

public class AllSort {
	//保存排序的结果
	private int[] recType = null;
	
	public AllSort(int[] arr) {
		recType = arr;
	}
	
////////////////////////插入排序 start/////////////////////////////
	//插入排序
	public void insertSort(int n) {
		int i,j;
		int tmp;
		for(i=1; i<n; i++) {
			tmp = recType[i];
			j = i - 1;
			while(j >= 0 && tmp < recType[j]) {
				recType[j+1] = recType[j];
				j--;
			}
			recType[j+1] = tmp;
		}
	}
	//二分插入排序
	public void insertSort1(int n) {
		int i,j,low,high,mid;
		int tmp;
		for(i=1; i<n; i++){
			tmp = recType[i];
			low = 0;
			high = i - 1;
			while(low <= high){
				mid = (low + high)/2;
				if(tmp < recType[mid])
					high = mid - 1;
				else
					low = mid + 1;
			}
			for(j=i-1; j>high+1; j--){
				recType[j+1] = recType[j];
			}
			recType[high+1] = tmp;
		}
	}
	//希尔排序
	public void shellSort(int n){
		int i,j,gap;
		int tmp;
		gap = n/2;
		while(gap>0){
			for(i = gap; i<n; i++){
				tmp = recType[i];
				j = i - gap;
				while(j >= 0 && tmp < recType[j]){
					recType[j+gap] = recType[j];
					j = j-gap;
				}
				recType[j+gap] = tmp;
			}
			gap = gap/2;
		}
	}
////////////////////////插入排序 end/////////////////////////////
	
////////////////////////交换排序 start/////////////////////////////
	//快速排序
	public void quickSort(int s,int t){
		int i = s,j = t;
		int tmp;
		if (s < t) {
			tmp = recType[s];
			while (i != j) {
				while(j > i && tmp <= recType[j])
					j--;
				recType[i] = recType[j];
				while(i < j && tmp > recType[i])
					i++;
				recType[j] = recType[i];
			}
			recType[i] = tmp;
			quickSort(s, i-1);
			quickSort(i+1, t);
		}
	}
	//冒泡排序
	public void bubbleSort() {
		int i,j,tmp;
		for(i=0; i<recType.length; i++){
			for(j=i+1; j<recType.length; j++){
				if (recType[i] > recType[j] ) {
					tmp = recType[i];
					recType[i] = recType[j];
					recType[j] = tmp;
				}
			}
		}
	}
	
////////////////////////交换排序 end/////////////////////////////	

////////////////////////选择排序 start///////////////////////////
	//简单选择排序
	public void selectionSort() {
		int i,j,tmp;
		for(i=1; i<recType.length; i++){
			tmp = recType[i];
			j=i-1;
			while(j>=0 && tmp<recType[j]){
				recType[j+1] = recType[j];
				j--;
			}
			recType[j+1] = tmp;
		}
	}
	
	//堆排序，排序是从数组的下标是1的元素开始排序的。
	public void heapSort() {
		for(int i=recType.length-1; i>0; i--){
			buildHeap(i);
			//每次排序完将将最大的元素调到最后
			recType[0] = recType[i];
			recType[i] = recType[1];
			recType[1] = recType[0];
		}
	}
	//调整二叉堆
	private void percolateDown (int hole, int currentSize) {
		int child;
		int tmp = recType[hole];
		for (; hole*2 <= currentSize; hole = child) {
			child = hole*2;
			if (child != currentSize && recType[child+1]>recType[child])
				child++;
			if (recType[child]>tmp)
				recType[hole] = recType[child];
			else
				break;
		}
		recType[hole] = tmp; 
	}
	private void buildHeap (int currentSize) {
		for (int i=currentSize/2; i>0; i--) 
			percolateDown(i, currentSize);
	}
////////////////////////选择排序 end/////////////////////////////	

	public void printArr(){
		for(int i=0; i<recType.length; i++ ){
			System.out.print(recType[i]+" ");
		}
	}
	
	public static void main(String[] args) {
		int[] arr = {0,5,2,3,8,9,7,5,4,11,25,22};
		AllSort allSort = new AllSort(arr);
//		allSort.quickSort(0, arr.length-1);
//		allSort.selectionSort();
		allSort.heapSort();
		allSort.printArr();
	}
}