題目描述

The cows are so very silly about their dinner partners. They have organized themselves into three groups (conveniently numbered 1, 2, and 3) that insist upon dining together. The trouble starts when they line up at the barn to enter the feeding area.

Each cow i carries with her a small card upon which is engraved Di (1 ≤ Di ≤ 3) indicating her dining group membership. The entire set of N (1 ≤ N ≤ 30,000) cows has lined up for dinner but it's easy for anyone to see that they are not grouped by their dinner-partner cards.

FJ's job is not so difficult. He just walks down the line of cows changing their dinner partner assignment by marking out the old number and writing in a new one. By doing so, he creates groups of cows like 111222333 or 333222111 where the cows' dining groups are sorted in either ascending or descending order by their dinner cards.

FJ is just as lazy as the next fellow. He's curious: what is the absolute mminimum number of cards he must change to create a proper grouping of dining partners? He must only change card numbers and must not rearrange the cows standing in line.

FJ的奶牛們在吃晚飯時很傻。他們把自己組織成三組（方便編號為1, 2和3），堅持一起用餐。當他們在穀倉排隊進入餵食區時，麻煩就開始了。

每頭奶牛都隨身帶著一張小卡片，小卡片上刻的是Di（1≤Di≤3）表示她屬於哪一組。所有的N（1≤N≤30000）頭奶牛排隊吃飯，但他們並不能按卡片上的分組站好。

FJ的工作並不是那麼難。他只是沿著牛的路線走下去，把舊的號碼標出來，換上一個新的。通過這樣做，他創造了一群奶牛，比如111222333或333222111，奶牛的就餐組按他們的晚餐卡片按升序或降序排列。

FJ就像任何人一樣懶惰。他很好奇：怎樣他才能進行適當的分組，使得他只要修改最少次數的數字？由於奶牛們已經很長時間沒有吃到飯了，所以“哞哞”的聲音到處都是，FJ只好更換卡號，而不能重新排列已經排好隊的奶牛。

輸入輸出格式

輸入格式：

* Line 1: A single integer: N

* Lines 2..N+1: Line i describes the i-th cow's current dining group with a single integer: Di

• 第1行：一個整數：n

• 第2~n+1行：第i-1行描述第i個奶牛目前分組。

輸出格式：

* Line 1: A single integer representing the minimum number of changes that must be made so that the final sequence of cows is sorted in either ascending or descending order

一個整數，表示必須做出的最小變化數，以便以升序或降序排序最終序列。

輸入輸出樣例

輸入樣例#1： 複製

5
1
3
2
1
1

輸出樣例#1： 複製

1

題解：本題找的是最小變化數，那如果找到最長的遞增或遞減序列，剩下的不就是最小的變化數了，最長遞增遞減序列很好用動規很好實現，但可惜的是On2的時間複雜度對本題來說有一組資料會超時，所以只好降低時間複雜度了，On2往下降就是Onlogn或者是On了，想到Onlogn有沒有想到二分，呵呵，沒錯，這裡就是使用的二分找到最長的遞增、遞減序列，並記錄最小的變化數。可以參考我之前寫的一篇部落格 遞增

超時寫法：

import java.util.*;
/*
 *一起吃飯
 */
public class Main{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[] a=new int[n+1];
        for(int i=1;i<=n;i++) {
        	a[i]=in.nextInt();
        }
        int[] d=new int[n+1];
        int[] p=new int[n+1];
        int max=0,max1=0,max2=0;
        for(int i=1;i<=n;i++) {
        	d[i]=1;p[i]=1;
        	for(int j=1;j<i;j++) {
        		if(a[i]>=a[j]) {
        			d[i]=Math.max(d[i], d[j]+1);
        		}
        		if(a[i]<=a[j]) {
        			p[i]=Math.max(p[i], p[j]+1);
        		}
        	}
        	max1=Math.max(max1, d[i]);
        	max2=Math.max(max2, p[i]);
        	max=Math.max(max1, max2);
        }
        System.out.println(n-max);
    }
}

二分解法：

import java.util.*;
/*
 *一起用餐吧
 */
public class Main{
    static int ns=1,ns1=1;
    static int[] s;
    static int[] s1;
    public static int bf(int x) {
    	int l=1,r=ns;
    	while(l<r) {
    		int mid=(l+r)/2;
    		if(s[mid]<x) {
    			r=mid;
    		}else
    			l=mid+1;
    	}
    	return l;
    }  
    public static int bf1(int x) {
    	int l=1,r=ns1;
    	while(l<r) {
    		int mid=(l+r)/2;
    		if(s1[mid]>x) {
    			r=mid;
    		}else
    			l=mid+1;
    	}
    	return l;
    }
	public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[] a=new int[n+1];
        for(int i=1;i<=n;i++) {
        	a[i]=in.nextInt();
        }
        s=new int[n+1];
        s[1]=a[1];
        int  res=0;		//用來記錄在最長遞增序列中需要變化的數
        for(int i=2;i<=n;i++) {
        	if(s[ns]<a[i]) {
        		s[bf(a[i])]=a[i];
        		res++;
        	}else
        		s[++ns]=a[i];
        }
        s1=new int[n+1];
        s1[1]=a[1];
        int  res1=0;	//用來記錄在最長遞減序列中需要變化的數
        for(int i=2;i<=n;i++) {
        	if(s1[ns1]>a[i]) {
        		s1[bf1(a[i])]=a[i];
        		res1++;
        	}else
        		s1[++ns1]=a[i];
        }
        System.out.println(Math.min(res, res1));
    }
}